Merge pull request #30 from theupriser/feat/apply-disabled

2.5.1: Add as non-Steam game, controller and apply button

.github/tools/bundle.sh

@@ -31,6 +31,28 @@ version="v$(grep -oP '^VERSION=\K.*' "$entry"), $(git describe --always --dirty
         sed -e '1{/^#!/d}' -e '/^# Sourced by steamify.sh/d' "lib/$lib.sh"
         echo
     done
+    # patches/ and services/ embedded: replace lib/common.sh's patch_file
+    # and service_raw, which read them from the checkout.
+    embed() {
+        local fn="$1" dir="$2" f
+        echo "# ----- $dir/ -----"
+        echo "$fn() {"
+        echo '    case "$1" in'
+        for f in "$dir"/*; do
+            [[ "$f" == "$dir/README.md" ]] && continue
+            grep -q '^STEAMIFY_PATCH_EOF$' "$f" && { echo "bundle: $f contains the heredoc delimiter" >&2; exit 1; }
+            echo "        $(basename "$f")) cat << 'STEAMIFY_PATCH_EOF'"
+            cat "$f"
+            echo "STEAMIFY_PATCH_EOF"
+            echo "            ;;"
+        done
+        echo '        *) return 1 ;;'
+        echo '    esac'
+        echo "}"
+        echo
+    }
+    embed patch_file patches
+    embed service_raw services
     echo "# ----- steamify.sh -----"
     echo "main() {"
     # Everything after the source loop is the entry point's body.

.github/workflows/bundle.yml

@@ -5,12 +5,18 @@
 # release are moved to it, so both of these always get the newest version:
 #   curl -fsSL https://github.com/theupriser/steamify-cachyos/releases/latest/download/steamify.sh | bash
 #   curl -fsSL https://github.com/theupriser/steamify-cachyos/releases/download/latest/steamify.sh | bash
+# Each release also has the app (v2): steamify-app.tar.gz (ui/, steamify.sh,
+# lib/, patches/, services/, the icon) and its launcher, run with:
+#   curl -fsSL https://github.com/theupriser/steamify-cachyos/releases/latest/download/steamify-app.sh | bash
+# A push to feat/v2-ui (the app, not released yet) updates the pre-release
+# v2-ui-preview instead, whose launcher gets that build:
+#   curl -fsSL https://github.com/theupriser/steamify-cachyos/releases/download/v2-ui-preview/steamify-app.sh | bash
 # Pull requests only build and check it, and warn when VERSION is already released.
 name: Single-file build
 
 on:
   push:
-    branches: [main]
+    branches: [main, feat/v2-ui]
   pull_request:
   workflow_dispatch:
 
@@ -28,17 +34,26 @@ jobs:
       - name: Build
         run: |
           .github/tools/bundle.sh dist/steamify.sh
+          # The app: sources, not the single-file build (its backend mode runs
+          # steamify.sh from its own folder).
+          tar -czf dist/steamify-app.tar.gz steamify.sh lib patches services ui assets/steam-gaming-settings.svg LICENSE.md
+          cp ui/steamify-app.sh dist/steamify-app.sh
 
       - name: Check
         run: |
           bash -n dist/steamify.sh
           # SC2034/SC2154: variables used across the inlined modules.
           shellcheck -S warning -e SC2034,SC2154 dist/steamify.sh
+          shellcheck -S warning dist/steamify-app.sh
+          python3 -m py_compile ui/steamify-ui
 
       - uses: actions/upload-artifact@v4
         with:
           name: steamify
-          path: dist/steamify.sh
+          path: |
+            dist/steamify.sh
+            dist/steamify-app.tar.gz
+            dist/steamify-app.sh
 
       - name: Version
         id: version
@@ -71,9 +86,13 @@ jobs:
 
               curl -fsSL https://github.com/${{ github.repository }}/releases/latest/download/steamify.sh | bash
 
+          Or the app (v2):
+
+              curl -fsSL https://github.com/${{ github.repository }}/releases/latest/download/steamify-app.sh | bash
+
           ## Changes in v$VERSION
           $changes"
-          gh release create "v$VERSION" dist/steamify.sh assets/steam-gaming-settings.svg \
+          gh release create "v$VERSION" dist/steamify.sh dist/steamify-app.sh dist/steamify-app.tar.gz assets/steam-gaming-settings.svg \
               --target "$GITHUB_SHA" --title "Steamify CachyOS v$VERSION" --notes "$notes" --latest
 
           # "latest" follows the newest version tag, for the older install URL
@@ -86,4 +105,24 @@ jobs:
           else
             gh release create latest --title "Steamify CachyOS - latest (v$VERSION)" --notes "$latest_notes" --latest=false
           fi
-          gh release upload latest dist/steamify.sh assets/steam-gaming-settings.svg --clobber
+          gh release upload latest dist/steamify.sh dist/steamify-app.sh dist/steamify-app.tar.gz assets/steam-gaming-settings.svg --clobber
+
+      - name: Publish the v2-ui-preview pre-release
+        if: github.event_name == 'push' && github.ref == 'refs/heads/feat/v2-ui'
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          # Its launcher downloads this pre-release, not the newest release.
+          sed -i 's/STEAMIFY_RELEASE:-latest/STEAMIFY_RELEASE:-v2-ui-preview/' dist/steamify-app.sh
+          grep -q 'STEAMIFY_RELEASE:-v2-ui-preview' dist/steamify-app.sh
+          git tag -f v2-ui-preview "$GITHUB_SHA" && git push -f origin v2-ui-preview
+          notes="Preview of the Steamify app (v2) from feat/v2-ui ($(git describe --always), $(git log -1 --format='%cs %s')). Not a release.
+          Run it with:
+
+              curl -fsSL https://github.com/${{ github.repository }}/releases/download/v2-ui-preview/steamify-app.sh | bash"
+          if gh release view v2-ui-preview >/dev/null 2>&1; then
+            gh release edit v2-ui-preview --title "Steamify app (v2) preview" --notes "$notes" --prerelease --latest=false
+          else
+            gh release create v2-ui-preview --target "$GITHUB_SHA" --title "Steamify app (v2) preview" --notes "$notes" --prerelease --latest=false
+          fi
+          gh release upload v2-ui-preview dist/steamify-app.sh dist/steamify-app.tar.gz --clobber

.gitignore

@@ -1 +1,2 @@
 dist/
+__pycache__/

AGENTS.md

@@ -15,6 +15,29 @@ gamescope and the Plasma desktop. Primary target: the Valve Steam Machine
 - `steamify.sh` - the only entry point. Pre-flight checks,
   sources `lib/*.sh`, runs the menu and applies the plan. No component
   logic here.
+- `patches/` - kernel module sources and patches the scripts build or
+  apply, never inline in the shell code. Read them with `patch_file
+  <name>` (`lib/common.sh`, from the checkout); the bundle embeds every file
+  in `patches/` and overrides `patch_file`. Add new ones to its README.
+- `services/` - the systemd units the scripts install (`.service`,
+  `.timer`, `.path`), never inline in the shell code. Read them with
+  `service_file <name> [KEY=value...]` (`lib/common.sh`), which fills in
+  `@KEY@` placeholders; the bundle embeds every file in `services/` too
+  (`service_raw`). Add new ones to its README. Small drop-ins for other
+  packages' units stay inline.
+- `ui/` - the app: `steamify-ui` (PySide6; runs `steamify.sh --backend`,
+  `lib/backend.sh`) and `ui/qml/`: `Main.qml` (window, header, which screen
+  shows), `AppState.qml` (all state and logic, input actions), one
+  `*Screen.qml` per screen, small widgets (`Btn`, `Chip`, `Badge`, ...), and
+  the singletons `Theme` (colours, fonts), `Texts` (item texts) and `Input`
+  (controller/keyboard/remote and its button names), listed in `qmldir`.
+  Screens get the `AppState` as `app` and only show it or call its functions.
+- **Paths.** Everything in the home folder lives under `steamify`:
+  `$STATE_DIR` (`~/.local/state/steamify`), `$STEAMIFY_DATA`/`$STEAMIFY_BIN`
+  (`~/.local/share/steamify/{app,bin}`), `lib/state.sh`. Never add files
+  under the old name `cachyos-gamescope-boot`; `migrate_layout` moves those
+  of older versions (symlinks keep older releases working). Keep the
+  `.bak-gamescope-wizard` backup suffix: existing backups are found by it.
 - `lib/*.sh` - one file per responsibility, each defining functions only
   (no top-level side effects besides constants). See the table in
   `TECHNICAL.md`.
@@ -25,6 +48,16 @@ gamescope and the Plasma desktop. Primary target: the Valve Steam Machine
   `<id>_available` is checked via `component_available` (e.g. `machine`
   only on Fremont). Turn-on order is `COMPONENTS` order, turn-off reverse;
   `gaming` must stay first. Dependencies live in `toggle_component`.
+- **Feature versions.** Set `FEATURE_VERSION[<id>]` (`lib/menu.sh`) to the new
+  `VERSION` whenever what `<id>_enable` sets up changes (a new component gets
+  one too): installs recorded with an older version
+  are ticked and re-applied ("update" in the plan and the app). New default
+  options are ticked for installs whose parent (top-level: `gaming`) is on
+  (`feature_new`, shown as "new").
+  Options shown but left unticked in a confirmed run are recorded as
+  `off` (`feature_record_unticked`), or `feature_new` would tick them again.
+  Status still comes from the system; don't add ad-hoc `<id>_repair` checks
+  for new changes.
 - **Reversibility.** Every per-user KDE setting a component changes goes
   through `kset <component> <file> <group|group> <key> <value>`
   (`lib/state.sh`), which records the old value once; `<id>_disable` calls
@@ -70,6 +103,10 @@ gamescope and the Plasma desktop. Primary target: the Valve Steam Machine
     changelog section) and marks it latest. An existing version is never
     overwritten: without a bump nothing is released, and pull requests show
     a warning.
+  - A release that adds, removes or renames a menu row also retakes the
+    README screenshot (`assets/screenshot-menu.png`): the app from the
+    branch on a Steam Machine, every row visible (window 1280 wide, tall
+    enough), the header showing the new `VERSION`, scaled to 1600 px wide.
   - Users install through `releases/latest/download/steamify.sh`
     (GitHub's newest release). The `latest` tag and release follow the newest
     version tag too (moved, asset replaced, when a new version is released),
@@ -125,7 +162,9 @@ gamescope and the Plasma desktop. Primary target: the Valve Steam Machine
   `restart_plasmashell_if_stopped` (`lib/common.sh`).
 - LED driver: `leds-valve-dkms-git`'s Makefile builds against `uname -r`,
   not DKMS's target kernel: `/etc/dkms/leds-valve-dkms.conf` sets
-  `MAKE[0]="make KVERSION=${kernelver}"` (written before the AUR install).
+  `MAKE[0]="make KVERSION=${kernelver}"` (written before the AUR install;
+  someone's own override there is backed up, kept with ours appended, and
+  restored on disable).
   Without it, other kernels build against the running kernel's tree and
   fail (CachyOS kernels are clang-built; DKMS adds `LLVM=1` only for the
   target's tree). Headers for every installed kernel are installed first,
@@ -142,7 +181,7 @@ gamescope and the Plasma desktop. Primary target: the Valve Steam Machine
   `steam-set-session plasma.desktop` plus the plasmalogin sync bridge when it
   exists, at every boot. CachyOS's `cachyos-gamescope-autologin` still sets
   gamescope during each desktop session; the unit corrects it at boot.
-- `bios` is an *action* (`ACTIONS` in `lib/menu.sh`), not an on/off
+- `bios` is an *action* (`ACTIONS` in `lib/menu.sh`) and a sub-option of `machine`, not an on/off
   component: never preselected (not even on a first run), never re-applied
   by `a`, not listed in the state overview, and `bios_status` is always off.
   Only selectable when Valve's version differs from the installed one
@@ -161,9 +200,14 @@ gamescope and the Plasma desktop. Primary target: the Valve Steam Machine
   now? [Y/n]" (`quit_prompt`): `n` goes back to the menu, the next `q` asks
   again. Scripted input that runs out quits without restarting (never
   restart on EOF: `ask_yn` would take its default).
-- Steamify shortcut (`launcher`): the icon runs `curl | bash` of
-  `releases/latest/download/steamify.sh` in Konsole, so it's
-  always the newest release. Its icon, `assets/steam-gaming-settings.svg`
+- Steamify shortcut (`launcher`): "Steamify CachyOS" (desktop and launcher,
+  id `steamify-ui.desktop`, the app's own id) runs `curl | bash` of
+  `releases/latest/download/steamify-app.sh` without a terminal (in Konsole
+  only while PySide6 is missing, for sudo); "Steamify Terminal" (launcher)
+  runs `steamify.sh` in Konsole. Both always the newest release. The entry
+  has `X-Steamify-Shortcut=true`: steamify-app.sh doesn't overwrite it, and
+  disable only removes it then. A pre-2.0.1 shortcut (terminal only) is
+  ticked by `launcher_repair`. Its icon, `assets/steam-gaming-settings.svg`
   (Valve's GPL-2.0 return icon with a gear), is a release asset too, and is
   downloaded from there (Steam's icon if that fails). Desktop files are
   written with their mode already set (`install_executable`): Plasma opens a
@@ -171,6 +215,60 @@ gamescope and the Plasma desktop. Primary target: the Valve Steam Machine
   The start script closes its window after a 10-second countdown on success
   and waits for Enter after an error; it uses `pipefail`, or a failed
   download would run an empty script and count as success.
+- HDMI refresh boost (`hdmi`, `lib/hdmi-refresh.sh`): retired in 2.2.0
+  (it needed the pinned kernel); only removal is left (see the power-off
+  fix below). `hdmi_enable` refuses. debugfs is root-only (glob it under
+  sudo), and `edid_override` takes exactly `reset` with no newline.
+- Steam Machine CEC driver (`cec_driver_enable`, `lib/cec.sh`): mainline
+  `cros_ec_cec` lacks Fremont, so HDMI-CEC builds Valve's copy (evlaV
+  `linux-integration`, pinned commit + SHA-256) with DKMS for every kernel.
+  It's patched to register its notifier without a port name when the board
+  has one CEC port: amdgpu registers its HDMI notifier nameless, and the
+  kernel only pairs that with a named lookup ("Port C") when the CEC driver
+  registered first, which never happens since amdgpu loads from the
+  initramfs. Without it `/dev/cec0` exists but stays at `f.f.f.f`.
+- Power-off fix (`poweroff`, `lib/fremont-poweroff.sh`, a default sub-option
+  of `machine`): recent kernels (7.2 and the 6.x/7.0/7.1 updates with the
+  backport) keep the firmware's S4/S5 wake bit on GPIO
+  pin 18, so the Steam Machine boots again right after powering off
+  (Valve's kernel clears it at probe, not for upstream). The DKMS module
+  `steamify-fremont-poweroff` (`patches/steamify-fremont-poweroff.c`) clears
+  it in a power-off-prepare handler, built for each kernel. It made the kernel pin
+  unnecessary: `kpin` is only available while on (`kpin_available`), and
+  `detect_components` unticks it, so a normal run removes an existing pin.
+  `hdmi` (it needed the pin) is retired the same way: `hdmi_status` is on
+  while anything of it is left (saved displays, hotplug unit, EDID files,
+  old kernel parameter), `hdmi_available` only then, it's always unticked,
+  and `hdmi_disable` removes all of it. CachyOS's
+  `linux-cachyos` is clang-built, `-bore` GCC-built: let DKMS pick the
+  compiler, never pass `LLVM=1`. Test shutdown on the real machine for every
+  new major kernel.
+- Add as non-Steam game (`steamgame`, `lib/steam-game.sh`, sub-option of
+  `launcher`, ticked along with it, 2.5.1): edits Steam's `shortcuts.vdf`
+  with `patches/steam-shortcuts.py` only while Steam is closed (Steam
+  rewrites it on exit), then starts Steam again. Never close Steam in gaming
+  mode or when `SteamGameId` is set (the run is a Steam game). An existing
+  entry for the start script is updated, not doubled; removal takes every
+  entry for it. Controller input through Steam's desktop layout arrives as
+  keys: Enter must select (A), Esc must never quit (B); the app re-execs
+  without Steam's overlay preload.
+- Update notifications (`notify`, `lib/update-notifier.sh`, top-level,
+  ticked by default, 2.5.0): a user timer (daily, and the service is wanted
+  by `plasma-workspace.target`) runs `patches/steamify-notifier.py`, which
+  compares GitHub's newest release with the `seen` version every run records
+  (`notify_seen` in the entry point, only while it's on, with `frontend`: app or terminal, which Open Steamify starts again, in a `systemd-run --scope` since the check's own unit is stopped when it exits). It must never
+  update anything itself: notification + tray icon, Open Steamify / Skip
+  this version (`skipped`). Desktop only (exits without `plasmashell`).
+- VRAM booster (`vram`, `lib/vram-booster.sh`, top-level, ticked by
+  default, 2.3.0; only available when `/sys/fs/cgroup/dmem.capacity` lists a
+  `vram`/`vidmem` region (numbered too) of at least 2 GB, whatever the brand;
+  greyed out with an NVIDIA card whose driver lists none, `vram_selectable`,
+  faked with `WIZARD_VRAM_FAKE_NVIDIA=1`; `WIZARD_VRAM_CAPACITY=<file>` reads
+  the regions from a copy): CachyOS's `dmemcg-booster` (system + user service) and
+  `plasma-foreground-booster`, like SteamOS 3.9's VRAM management. The
+  latter only starts with `kcgroupsrc [Foreground Booster] autostart=true`
+  (set with `kset`). Disable removes only the packages it installed
+  (`state_get vram installed_pkgs`).
 - `Relogin=true` means a gamescope that fails to start is relaunched in a
   tight loop; keep that in mind when changing session handling.
 

CHANGELOG.md

@@ -5,6 +5,191 @@ All notable changes, per version and per commit. Versions follow
 `steamify.sh`. Versions before 0.7.0 were numbered afterwards,
 one per merged pull request.
 
+## 2.5.1 - 2026-09-27
+
+- **fix: Add as non-Steam game asks Steam to close again every 15 s (a Steam that was still starting ignored it)**
+- `3a0692f` **docs: README screenshot at 2.5.1 with Add as non-Steam game**
+- `e86ddcc` **feat: Add as non-Steam game: Steamify in the Steam library, under the shortcut; controller works when started from Steam**
+- `389bc33` **fix(ui): B never quits (Steam sends Esc for it), Ctrl+Q does; started from Steam, the hints show the Steam Controller's buttons**
+- `c6c1150` **fix(ui): Enter selects (a Steam Controller's A in Steam's desktop layout); Ctrl+Enter reviews and applies**
+- `98e2eff` **fix(ui): Started from Steam, the app runs without Steam's overlay (Qt aborted) and stays in the foreground, so Steam Input gives it the controller**
+- `431515b` **feat(ui): Review & apply greyed out while nothing would change; the Done screen shows why a run stopped**
+
+## 2.5.0 - 2026-09-27
+
+- **docs: README: what the VRAM booster says with NVIDIA's closed driver; shorter unsupported text in the app**
+- `32c33e4` **fix: An option left unticked stays off: it came back ticked as "new" on the next run (since 2.3.0)**
+- `2dd0f3a` **feat: VRAM booster with NVIDIA says what to do: update, switch to the open driver (chwd command), or not supported by the card**
+- `57995bc` **docs: VRAM booster works with NVIDIA's open kernel modules (driver 615+); only the closed driver is greyed out**
+- `d57e8d8` **docs: AGENTS.md and changelog for the vidmem detection**
+- `5a34633` **feat: VRAM booster also for drivers that name their region vidmem (or numbered), NVIDIA included once its driver registers it**
+- `479b70b` **feat: Everything in the home folder under steamify (state, scripts, icon), moved once from the old name**
+- `2e0881b` **fix: fill takes values literally; the notifier path is quoted in its unit**
+- `cce31e1` **refactor: DKMS confs in patches/; an existing leds-valve DKMS override is kept and restored**
+- `bd4fa3a` **refactor: The session sync and kernel headers scripts in patches/**
+- `8ffa0f2` **refactor: systemd units in services/, read with service_file like patches/**
+- `8a2601d` **docs: README screenshot at 2.5.0 with Update notifications; AGENTS.md: retake it when rows change**
+- `572417b` **fix: Open Steamify from the notification starts the app (own scope), the same way it was last used (app or terminal)**
+- `cf73229` **feat: Update notifications: a notification and tray icon when there's a new Steamify**
+
+## 2.4.1 - 2026-09-27
+
+- **chore: Version 2.4.1**
+- `6f598d1` **docs: README screenshot shows every option**
+- `9bbe5fa` **docs: Screenshot of the app's menu in the README**
+
+## 2.4.0 - 2026-09-27
+
+- `03a8b8c` **chore: Version 2.4.0**
+- `e699a3f` **refactor(ui): One QML file per screen; the HDMI boost's setup screens and backend commands removed**
+
+## 2.3.0 - 2026-09-27
+
+- `86b9744` **feat: VRAM booster greyed out with an NVIDIA card, with why**
+- `b0947d7` **feat: VRAM booster only for GPUs with at least 2 GB of their own VRAM**
+- `3f97c85` **feat: VRAM booster for every supported GPU, not only the Steam Machine**
+- `fd162c1` **feat: New badge for default sub-options added in this version**
+- `54ebddf` **feat: VRAM booster for the Steam Machine**
+
+## 2.2.0 - 2026-09-27
+
+- `ef585c0` **docs: Changelog entries per commit for 2.2.0**
+- `32795bd` **feat(ui): Update badge on the progress screen**
+- `3c8ca65` **fix(ui): Never write the sudo password to a file; Update label on the progress screen**
+  - The app gave `sudo` the password through a short-lived file; the helper
+    now reads it from a named pipe the app feeds from memory each time sudo
+    asks. The progress screen showed "undefined" for an update.
+- `11a91ef` **feat: Update badge on components that get a newer version**
+  - The menu (terminal and app) shows "(update)" / an Update badge after
+    the name of a component a normal run will update.
+- `163f790` **feat: Feature versions are Steamify versions; Steam Machine support is 2.2.0**
+  - Each component records the Steamify version of what it set up; when a
+    release changes a component, installs with an older version are ticked
+    and updated by a normal run ("update" in the plan and the app's
+    review). A setup from before counts as 2.1.0, so Steam Machine support
+    (2.2.0) is updated on machines set up with 2.1.0. New default
+    sub-options (like the power-off fix) are ticked where their parent is on.
+- `e121b06` **fix: Remove whatever is left of HDMI refresh boost, pin or no pin**
+  - HDMI refresh boost needed the pinned kernel and is retired (newer
+    kernels do HDMI 2.1 themselves): whatever is left of it (saved
+    displays, also ones not connected, its hotplug script, the old kernel
+    parameter) is unticked and removed by the next run.
+- `19ca966` **docs: Drop the kernel pin and HDMI refresh boost descriptions**
+- `56fb908` **docs: Power-off fix texts cover every affected kernel, not just 7.2**
+- `6df19eb` **feat: Power-off fix as its own sub-option, drop the kernel pin, feature versions**
+  - The power-off fix is a sub-option of Steam Machine support, ticked
+    along with it (opt-out). The kernel pin is no longer offered: an
+    existing pin is shown unticked, so the next run removes it and brings
+    back CachyOS's current kernel.
+- `7694c97` **feat: Power-off fix for the Steam Machine; the kernel pin is optional**
+  - With recent kernels (newer 6.x, 7.0 and 7.1 updates, 7.2 and probably
+    later ones) the Steam Machine started again right after shutting down:
+    they keep the wake bit the firmware sets on GPIO pin 18, which Valve's
+    own kernel clears in a patch that won't reach CachyOS. A small module,
+    built with DKMS for each installed kernel, clears it right before
+    power-off. Tested with CachyOS 7.2.8: stays off, and without the module
+    it rebooted.
+  - Module sources and patches live in `patches/` instead of inside the
+    shell code; the single-file build and the app package include them. The
+    Steam Machine CEC driver change is now
+    `patches/cros-ec-cec-single-port.patch`.
+
+## 2.1.0 - 2026-09-26
+
+- **feat(ui): Manage button for HDMI refresh boost**
+  - The item's switch is a button: Set up… while no display is saved,
+    Manage after that. Manage lists the saved displays (connected or not),
+    removes one with its Remove button, and sets up the connected display
+    when it has no saved rates yet.
+- **4cc87aa feat: HDMI refresh boost per display, with a Saved displays screen**
+- **36d0a9d feat: HDMI refresh boost only for the display it was set up for**
+  - The EDID override was on the kernel command line, so any display on that
+    HDMI port got the first display's timings. Rates are now saved per
+    display and loaded at boot and at every hotplug for the display that's
+    connected (its ID read over DDC); a display without saved rates, or
+    unplugging, puts the port back on the display's own EDID. No initramfs
+    or boot loader change any more. An existing setup is moved over when
+    re-applied (`a`).
+  - The item shows on only while the connected display is boosted, so a new
+    display can be set up by ticking it; unticking removes only that one.
+
+## 2.0.3 - 2026-09-26
+
+- **fix: HDMI-CEC on the Steam Machine**
+  - Mainline's `cros_ec_cec` driver doesn't know the Steam Machine, so there
+    was no `/dev/cec0`. HDMI-CEC now builds Valve's version of the driver
+    with DKMS (`steamify-cros-ec-cec`) for every installed kernel, with a fix
+    so it finds amdgpu's HDMI port even though amdgpu loads first. An
+    existing HDMI-CEC install is ticked in the menu to add it.
+
+## 2.0.2 - 2026-09-26
+
+- **badfd84 docs: Non-affiliation disclaimer in the README**
+  - States that the project isn't affiliated with Valve or CachyOS, and that
+    Steam and SteamOS are Valve's trademarks.
+
+## 2.0.1 - 2026-09-25
+
+- **2b3f1de feat: The Steamify shortcut opens the app**
+  - "Steamify CachyOS" on the desktop and in the launcher starts the newest
+    app (in Konsole the first time, if PySide6 still has to be installed).
+    The terminal menu is "Steamify Terminal" in the launcher. A shortcut from
+    before 2.0.1 is ticked in the menu, so a normal run replaces it.
+  - steamify-app.sh leaves the shortcut's launcher entry alone (it has the
+    same id, `steamify-ui.desktop`, and always starts the newest release).
+
+## 2.0.0 - 2026-09-25
+
+- **feat: Steamify app (v2 UI)**
+  - A graphical app for controller, keyboard and TV remote, driving the same
+    components through `steamify.sh --backend`; the BIOS update with both
+    warnings; built by GitHub and run with curl.
+- **feat(ui): HDMI refresh boost in the app**
+  - "Set up…" opens its own screen: the display, its resolution and the
+    rates on offer (its own mode, calculated tens, the HDMI 2.0 limit). The
+    display's own faster mode is switched to right away; every other rate
+    has a Try button (switch live, wait for the picture, then keep it within
+    15 s or it switches back) and a tick box. Install installs the ticked
+    rates. All rates are loaded when the screen opens, so a try is only a
+    mode switch.
+  - Unticking Steam Machine support or the kernel pin unticks it, as in the
+    menu.
+- **fix(ui): The details panel scrolls instead of overflowing**
+- **fix: Switching back to a rate like 59.97 Hz**
+  - `hdmi_set_mode` compared it as a whole number and printed an error.
+
+## 1.2.0 - 2026-09-25
+
+- **feat: HDMI refresh boost (Steam Machine, pinned kernel)**
+  - The pinned 7.1.6 kernel doesn't read the extra EDID block where monitors
+    list their fast modes, and does no HDMI 2.1, so HDMI displays often stay
+    at 60 Hz. The new menu item reads the display's EDID over DDC,
+    calculates the highest rate that fits HDMI 2.0 at the desktop resolution
+    (rounded down to ten, plus the hundred below as a safe option), tests
+    each step live with a confirmation, and makes the confirmed ones
+    permanent through `drm.edid_firmware` (Limine, sdboot-manage or GRUB).
+- **feat: HDMI refresh boost and Update BIOS under Steam Machine support**
+  - Both are sub-options now, shown only while Steam Machine support is
+    ticked. Unticking it unticks them; unticking the kernel pin unticks the
+    HDMI refresh boost.
+
+## 1.1.4 - 2026-09-25
+
+- **fix: No lock screen in single user mode before a restart**
+  - The screen locker only read the new settings at the next login, so the
+    PC still locked after 5 minutes idle until then. Turning single user
+    mode on or off now tells it to reload them right away.
+
+## 1.1.3 - 2026-09-25
+
+- **fix: HDMI-CEC settings shown in Steam**
+  - CachyOS's gaming mode script sets `STEAM_ENABLE_CEC=0`, which hides
+    Steam's HDMI-CEC settings (and its CEC volume buttons). HDMI-CEC now adds
+    a drop-in for `steam-launcher.service` that overrides it with
+    `STEAM_ENABLE_CEC=1` (`/etc/steamify/steam-cec.env`).
+  - HDMI-CEC set up by 1.1.0-1.1.2 shows as off and ticked, so a normal run
+    (Enter) adds this.
+
 ## 1.1.2 - 2026-09-25
 
 - **fix: Steam's HDMI-CEC settings reach cecd on a first run**

README.md

@@ -1,5 +1,7 @@
 # Steamify CachyOS
 
+![The Steamify app's menu on a Steam Machine](assets/screenshot-menu.png)
+
 Turn a CachyOS desktop PC into a SteamOS-style console: it boots straight
 into Steam's Big Picture (gamescope), and you can switch to the KDE Plasma
 desktop and back whenever you like - just like on a Steam Deck or Valve's
@@ -25,9 +27,26 @@ Steam Machine.
    KDE wallet password prompts (e.g. from Brave). Typing a password with a
    controller is no fun
    ([details](TECHNICAL.md#single-user-mode-sddm-no-locking)).
-5. **Steamify shortcut** - an icon on the desktop and in the launcher that
-   opens the newest Steamify, so you don't need the install command again.
-6. **HDMI-CEC** (experimental; off by default, on by default on a Steam
+5. **Steamify shortcut** - "Steamify CachyOS" on the desktop and in the
+   launcher opens the newest Steamify app, so you don't need the install
+   command again. "Steamify Terminal" in the launcher opens the terminal menu.
+   With **Add as non-Steam game** (on by default) it's in your Steam library
+   too: started from Steam it gets your controller (a Steam Controller only
+   talks to Steam), in gaming mode as well. Steam closes for a moment while
+   it's added, so that's done from the desktop.
+6. **Update notifications** - on by default: a notification and a tray icon
+   when there's a new Steamify, with Open Steamify and Skip this version. It
+   never updates anything by itself
+   ([details](TECHNICAL.md#update-notifications)).
+7. **VRAM booster** - on by default: the game you're playing keeps its video
+   memory and background apps make room, like SteamOS 3.9. Shown for GPUs
+   whose driver supports it (AMD, Intel, NVIDIA with its open kernel modules
+   from driver 615) on kernel 7.2 or newer. With NVIDIA's closed driver it's
+   greyed out and says what to do: switch to the open driver when your card
+   supports it (RTX 20 series and newer; Steamify shows the command, it
+   doesn't switch drivers itself)
+   ([details](TECHNICAL.md#vram-booster)).
+8. **HDMI-CEC** (experimental; off by default, on by default on a Steam
    Machine) - use Steam with your TV's
    remote, and the TV turns on and off with the PC. Needs a PC with CEC (like
    the Steam Machine) or a USB CEC adapter; most graphics cards, NVIDIA
@@ -42,17 +61,14 @@ What Steamify can do on a Valve Steam Machine:
   TV's remote, and the TV turns on and off with the Steam Machine
   ([details](TECHNICAL.md#hdmi-cec)).
 - **Steam Machine support** - the front **LED bar** works, Steam's
-  **hardware settings** (fan, performance) work, and the power
-  button puts it to sleep like a console.
-  - **Pin the kernel to 7.1.6-1** - on by default: with newer CachyOS kernels
-    the Steam Machine reboots instead of shutting down. Untick it once CachyOS
-    fixes that. The kernel comes from its own
-    [release](https://github.com/theupriser/steamify-cachyos/releases/tag/kernel-7.1.6-1),
-    checked against CachyOS's signature
-    ([details](TECHNICAL.md#kernel-pin-steam-machine)).
-- **Update BIOS** - installs Valve's newest Steam Machine BIOS. Never ticked
-  by default, at your own risk, and only after two warnings
-  ([details](TECHNICAL.md#bios-updates-steam-machine)).
+  **hardware settings** (fan, performance) work, and the power button puts
+  it to sleep like a console.
+  - **Power-off fix** - on by default: shutting down really turns the Steam
+    Machine off, also with the newest CachyOS kernel
+    ([details](TECHNICAL.md#power-off-fix-steam-machine)).
+  - **Update BIOS** - installs Valve's newest Steam Machine BIOS. Never ticked
+    by default, at your own risk, and only after two warnings
+    ([details](TECHNICAL.md#bios-updates-steam-machine)).
 
 ## Requirements
 
@@ -124,3 +140,11 @@ Contributing (or an AI agent)? Read [AGENTS.md](AGENTS.md).
 ## License
 
 MIT - do whatever you want with it. See [LICENSE.md](LICENSE.md).
+
+## Disclaimer
+
+Steamify CachyOS is an unofficial community project. It is not affiliated
+with, endorsed by, or sponsored by Valve Corporation or the CachyOS project.
+Steam, SteamOS and the Steam logo are trademarks of Valve Corporation. CachyOS
+is the name of its respective project. They are used here only to describe
+what this script works with.

TECHNICAL.md

@@ -14,7 +14,7 @@ and turns on what you ticked. To be able to undo:
   off.
 - **KDE settings** in your home directory are recorded with their previous
   value the first time the wizard changes them, in an undo journal under
-  `~/.local/state/cachyos-gamescope-boot/`. Turning the component off writes
+  `~/.local/state/steamify/`. Turning the component off writes
   the old values back (or removes keys that didn't exist before). Setups
   made by older versions of the script, without a journal, fall back to
   KDE's defaults.
@@ -192,6 +192,13 @@ devices found. Also turn on CEC on the TV
 `steamos-manager` writes cecd's settings from Steam's (wake the TV, put it to
 sleep), in `~/.config/cecd/config.d/`, and Steam shows its HDMI-CEC
 settings; the wizard restarts steamos-manager so that happens right away.
+CachyOS's gaming mode script (`/usr/lib/steamos/gamescope-session`) sets
+`STEAM_ENABLE_CEC=0`, which hides those settings; Steam reads the script's
+variables from `$XDG_RUNTIME_DIR/gamescope-environment`. HDMI-CEC adds a
+drop-in for `steam-launcher.service`
+(`/etc/systemd/user/steam-launcher.service.d/10-steamify-cec.conf`) with a
+second `EnvironmentFile=` (`/etc/steamify/steam-cec.env`,
+`STEAM_ENABLE_CEC=1`), which overrides it from the next gaming mode start.
 
 It's experimental: on SteamOS itself CEC can wake the Steam Machine right
 after it goes to sleep (Samsung TVs,
@@ -201,26 +208,145 @@ upset CEC for the TV's other devices
 Turning it off removes the packages again (`linuxconsole` only if the
 wizard installed it).
 
-## Kernel pin (Steam Machine)
+## Power-off fix (Steam Machine)
 
-With CachyOS kernels newer than 7.1.6 a Steam Machine reboots instead of
-shutting down. The **Pin the kernel** sub-option (ticked along with Steam
-Machine support) installs `linux-cachyos` and `linux-cachyos-headers`
-7.1.6-1 and adds them to `IgnorePkg` in `/etc/pacman.conf`, so updates skip
-them. DKMS builds the LED driver for it; restart to boot it.
+With recent kernels a Steam Machine starts again right after powering off:
+the newer 6.x, 7.0 and 7.1 updates and 7.2 (and probably every kernel after
+it). Linux stopped clearing the S4/S5 wake bits at probe
+(`pinctrl-amd: Don't clear S4 wake bits at probe`, in 7.2 and backported to
+stable kernels), and the firmware leaves
+that bit set on GPIO pin 18 (`_SB.PCI0.GPP6`). Valve's own kernel
+(`linux-neptune-72`) clears it at probe on Fremont, in a patch marked not
+for upstream ("until the firmware is fixed"), so CachyOS and mainline won't
+get it.
 
-The packages (and their signatures, which pacman checks) are kept in
-`/var/cache/steamify/kernel`, so re-applying needs no download. Missing
-files are taken from pacman's cache, else downloaded from this repo's
-`kernel-7.1.6-1` release, then `archive.cachyos.org`, then
-`mirror.cachyos.org` (which only has the current kernel). Every file must
-match the SHA-256 in the script and have a valid CachyOS signature; a bad
-one is deleted, so the next run downloads it again. Set `PINNED_KERNEL_URL`
-to a directory URL with the files to try another source first, or drop them
-into the kernel directory yourself.
+The **Power-off fix** sub-option of Steam Machine support (ticked along with
+it, can be unticked) builds a small module with DKMS for every installed
+kernel, `steamify-fremont-poweroff` (source in
+[`patches/steamify-fremont-poweroff.c`](patches/steamify-fremont-poweroff.c)).
+It only loads on Fremont (DMI board name) and touches one register: right
+before power-off (a `SYS_OFF_MODE_POWER_OFF_PREPARE` handler, after the
+drivers have shut down) it clears that pin's S4/S5 wake bit. On a kernel
+that already clears it, it does nothing. It logs the pin's state at load:
+`dmesg | grep 'GPIO 18'`; `/sys/kernel/debug/gpio` shows the S4/S5 column.
+Tested on a Steam Machine with `linux-cachyos-bore` 7.2.8: it stayed off
+three times in a row, and rebooted right away with the module unloaded.
 
-Unticking it removes the pin and runs `sudo pacman -Syu`, which brings the
-kernel back to CachyOS's current version; the files stay for next time.
+Where Steam Machine support was set up before 2.2.0, the menu ticks the
+power-off fix as a new default sub-option (see feature versions below), so a
+normal run adds it.
+
+## Add as non-Steam game
+
+A sub-option of the Steamify shortcut (`steamgame`, `lib/steam-game.sh`, new
+in 2.5.1, ticked along with the shortcut): Steamify CachyOS in every Steam
+account's non-Steam games (`~/.local/share/Steam/userdata/<id>/config/shortcuts.vdf`,
+binary VDF, edited by `patches/steam-shortcuts.py`), starting the shortcut's
+`run-app`, with the icon rendered as PNG (`~/.local/share/steamify/steamify.png`;
+Steam shows no SVG). Why: while Steam runs, a Steam Controller only talks to
+Steam, which gives its input to the game it started (Steam Input); on the
+desktop through its desktop layout (A = Enter, B = Esc, Y = Space, X =
+Steam's keyboard), in gaming mode as a gamepad.
+
+Steam reads the list only at startup and writes it back on exit, so Steam is
+closed (`steam -shutdown`) for the edit and started again (through
+`steam-desktop-autostart.service` when it's there). That's refused in gaming
+mode and when Steamify itself was started from Steam (`SteamGameId`), since
+closing Steam would end it. An entry for the start script that's already
+there (added by hand, or with the path from before 2.5.0) is updated, not
+added twice; what was done is recorded per account (state `steamgame`:
+`<account>=<appid> added|updated`) and a copy of each list is kept in the
+state directory before the first change. Turning it off (or the shortcut)
+removes every entry for the start script, since it can't start anything
+without it.
+
+Started from Steam, the app re-executes itself without Steam's overlay
+(`LD_PRELOAD` of `gameoverlayrenderer.so` makes Qt abort) and
+`steamify-app.sh` keeps it in the foreground (`SteamGameId`), or Steam
+counts the game as ended right away and stops giving it the controller.
+
+## Update notifications
+
+The **Update notifications** option (new in 2.5.0, ticked by default)
+installs `patches/steamify-notifier.py` as
+`~/.local/share/steamify/bin/steamify-notifier` with two user
+units in `~/.config/systemd/user`: `steamify-update-check.timer` (daily,
+`Persistent=`) and `steamify-update-check.service` (also wanted by
+`plasma-workspace.target`, so it checks a minute after each desktop login).
+Nothing stays running while there's no update.
+
+Every Steamify run records its version as `seen` (`notify.state`). The check
+asks GitHub for the newest release; when it's newer than `seen` and not the
+`skipped` version, it shows a notification (`notify-send` with the buttons
+**Open Steamify** and **Skip this version**) and a tray icon (click: open;
+menu: open, skip, remind me later). Closing the notification keeps the
+icon; opening Steamify in any way records the new version and ends it. It
+only runs on the Plasma desktop: gamescope shows no notifications or tray,
+so an update found in gaming mode waits for the next desktop login. It never
+installs anything: the shortcut always starts the newest release, which then
+shows what's new or updated for this install.
+
+## VRAM booster
+
+SteamOS 3.9 manages the dGPU's VRAM per cgroup: the game in front is
+protected, background apps are evicted first. Without it a game that needs
+most of the VRAM (8 GB on the Steam Machine) can be pushed into system RAM
+by the desktop and other apps, and stutter. The kernel side is the `dmem`
+cgroup controller (7.2); amdgpu and Intel's xe register their VRAM with it
+(`drm/<pci>/vram`), NVIDIA's open kernel modules from driver 615 too
+(`nvidia/<pci>/vidmem`); `dmemcg-booster` protects every region it lists,
+whatever its name. NVIDIA's closed modules don't: with such a card the option is shown greyed
+out with what to do (`vram_nvidia_case`): open modules older than 615 ->
+update; the closed driver on a card the open one supports (not in chwd's
+legacy lists `/var/lib/chwd/ids/nvidia-{580,470,390}.ids`) -> the `chwd`
+commands to switch, never switched by Steamify itself (a failed switch
+means a black screen, and it can't be tested here); a legacy card or
+nouveau -> not supported. Shown greyed
+out, with why, until its driver lists a region: then it's offered like any
+other (`WIZARD_VRAM_FAKE_NVIDIA=1` fakes the grey-out, `WIZARD_VRAM_CAPACITY=<file>`
+reads the regions from a copy, for tests). Otherwise
+the **VRAM booster** option is only shown when
+`/sys/fs/cgroup/dmem.capacity` lists a VRAM region (`vram`, or `vidmem`
+as other drivers name it, numbered with several) of at least 2 GB (a
+dedicated GPU; an integrated one registers a small carve-out) or it's already on, and is
+ticked by default; new in 2.3.0, so setups with the SteamOS conversion on
+get it ticked. CachyOS packages the userspace side, which it installs:
+
+- `dmemcg-booster`: `dmemcg-booster-system.service` enables the `dmem`
+  controller and sets `dmem.low` for the cgroup in front;
+  `dmemcg-booster-user.service` runs in the user session.
+- `plasma-foreground-booster`: tells it which window is in front on the
+  desktop. It only starts with `autostart=true` under `[Foreground Booster]`
+  in `kcgroupsrc`, which the wizard sets (and reverts).
+
+Check it with `cat /sys/fs/cgroup/cgroup.subtree_control` (lists `dmem`) and
+the `dmem.low` of the slices under `user@<uid>.service`. Turning it off
+disables the services and removes the packages the wizard installed.
+Not added: a fixed `dmem.max` cap for `app.slice` (as some guides do); only
+worth it if the booster itself turns out to cause stutter.
+
+## Feature versions (updates)
+
+Each component has a feature version (`FEATURE_VERSION` in `lib/menu.sh`):
+the Steamify version in which what it sets up last changed (2.1.0 for
+everything that hasn't changed since). After a component is turned on
+successfully, that version is recorded in `~/.local/state/steamify/features.state`
+(turning it off records `off`). Whether a component is on is always checked
+on the system itself; the version only decides about updates:
+
+- **On, recorded version older** than the current one: ticked and
+  re-applied by a normal run; the plan (and the app's review) says
+  "update". A setup from before versions were recorded counts as 2.1.0,
+  so on a machine set up with 2.1.0, Steam Machine support (2.2.0) is
+  updated.
+- **A new default option** (not in `NO_PRESELECT`) whose parent is on (for
+  a top-level one: the SteamOS conversion) and that was never turned on or
+  off: ticked, so a normal run adds it. Turning it off once records `off`,
+  so it isn't ticked again. The menu and the app show it with a **New**
+  badge, and the plan says "new in this version".
+
+Set a component's entry to the new `VERSION` whenever what its
+`<id>_enable` sets up changes.
 
 ## BIOS updates (Steam Machine)
 
@@ -258,6 +384,31 @@ To walk through it without flashing anything, run the wizard with
 `WIZARD_BIOS_DRY_RUN=1`: it downloads and checks the package and shows both
 warnings, skips fwupd's device check, and only prints the install command.
 
+## Where Steamify keeps its files
+
+In the home folder, everything is under `steamify`:
+
+| Where | What |
+|---|---|
+| `~/.local/state/steamify/` | State (`*.state`), undo journals (`*.journal`), the saved panel layout (`theme-layout/`) |
+| `~/.local/share/steamify/app/` | The app (`steamify-app.sh` downloads it here) |
+| `~/.local/share/steamify/bin/` | The shortcut's start scripts (`run-app`, `run-wizard`) and `steamify-notifier` |
+| `~/.local/share/icons/hicolor/scalable/apps/steamify.svg` | The shortcut's icon |
+| `~/.local/share/applications/steamify-*.desktop` | The launcher entries |
+| `~/.config/systemd/user/` | `steamify-update-check.*`, `steam-desktop-autostart.service` |
+
+System-wide: `/usr/local/lib/steamify/` (kernel headers script),
+`/usr/src/steamify-*` (DKMS modules), `/var/cache/steamify/kernel` (the old
+kernel pin's packages), and `*.bak-gamescope-wizard` backups next to the
+system files that were edited (that name stays: it's how they're found again).
+
+Before 2.5.0 the home folder paths used the project's old name
+(`cachyos-gamescope-boot`). `migrate_layout` (`lib/state.sh`) moves them at
+every start of a newer version, once, and leaves symlinks under the old names
+so an older release still finds the same state; it fixes the paths in the
+launcher entries and the update check's unit, and merges when both exist.
+The headers script moves when Steam Machine support is set up again.
+
 ## Manual session control
 
 ```bash
@@ -290,8 +441,14 @@ immediately, which can turn into a loop - see
 | `lib/wizard-shortcut.sh` | Steamify shortcut: desktop icon and launcher entry that run the newest release |
 | `lib/bios.sh` | Update BIOS (Steam Machine, opt-in): current/newest version, double confirmation, fwupd |
 | `lib/cec.sh` | HDMI-CEC: Valve's `cecd` and friends from its `holo` repository |
-| `lib/steam-machine.sh` | Steam Machine support: LED driver, LED access, steamos-manager; kernel pin |
-| `.github/tools/bundle.sh` | Builds the single-file version (`dist/steamify.sh`) |
+| `lib/steam-machine.sh` | Steam Machine support: LED driver, LED access, steamos-manager |
+| `lib/fremont-poweroff.sh` | Steam Machine support: the power-off fix (DKMS module from `patches/`) |
+| `lib/steam-game.sh` | Add as non-Steam game: Steamify in the Steam library (`patches/steam-shortcuts.py`) |
+| `lib/update-notifier.sh` | Update notifications: the notifier from `patches/` and its user timer |
+| `lib/vram-booster.sh` | VRAM booster (`dmemcg-booster`, `plasma-foreground-booster`) |
+| `services/` | The systemd units the scripts install (`service_file`, `@KEY@` placeholders); see its README |
+| `patches/` | Module sources and patches the scripts build or apply (`patch_file`); see its README |
+| `.github/tools/bundle.sh` | Builds the single-file version (`dist/steamify.sh`), with `patches/` and `services/` embedded |
 | `.github/workflows/bundle.yml` | Builds and checks it on every push; publishes it on `main` |
 
 The single-file version is generated: on every push to `main`, GitHub

lib/backend.sh

@@ -0,0 +1,192 @@
+#!/bin/bash
+# Machine-readable mode for the graphical app (steamify-ui): the same
+# components and plan as the menu, as JSON on stdout.
+#   steamify.sh --backend status
+#       one JSON object: version, machine, and every menu item with its
+#       current state and what a run would pick by default.
+#   steamify.sh --backend apply [--reapply] [--boot gamescope|desktop] <id>...
+#       turns on the listed components and off the others (like ticking them
+#       in the menu), then streams one JSON object per line: plan, start,
+#       log, done, finished. sudo asks through $SUDO_ASKPASS (no terminal).
+#   steamify.sh --backend bios-prepare | bios-flash
+#       the BIOS update in two steps, so the app shows both warnings between
+#       them (bios-ready event: current, newest, checksum, compatible).
+# Sourced by steamify.sh; not meant to be run on its own.
+
+json_str() {
+    # json_str <text>: <text> as a JSON string (quotes, backslashes and
+    # control characters escaped; colour codes dropped).
+    local s="$1"
+    s="$(printf '%s' "$s" | sed -E $'s/\x1b\\[[0-9;]*[A-Za-z]//g')"
+    s="${s//\\/\\\\}"; s="${s//\"/\\\"}"
+    s="${s//$'\t'/\\t}"; s="${s//$'\r'/}"; s="${s//$'\n'/\\n}"
+    s="$(printf '%s' "$s" | tr -d '\000-\010\013\014\016-\037')"
+    printf '"%s"' "$s"
+}
+
+json_list() {
+    # json_list <item>...: a JSON array of strings.
+    local out="" x
+    for x in "$@"; do out+="${out:+,}$(json_str "$x")"; done
+    printf '[%s]' "$out"
+}
+
+backend_event() {
+    # backend_event <event> [<json fields without braces>]
+    printf '{"event":%s%s}\n' "$(json_str "$1")" "${2:+,$2}"
+}
+
+backend_status() {
+    local c first_run=true items="" kind parent now
+    detect_components
+    for c in "${COMPONENTS[@]}"; do
+        component_available "$c" && ! is_action "$c" && [[ "${CURRENT[$c]}" == 1 ]] && first_run=false
+    done
+    for c in "${COMPONENTS[@]}"; do
+        component_available "$c" || continue
+        kind=toggle; is_action "$c" && kind=action; [[ "$c" == boot ]] && kind=choice
+        parent="${PARENT[$c]:-}"
+        now="${CURRENT[$c]:-0}"
+        items+="${items:+,}{\"id\":$(json_str "$c"),\"label\":$(json_str "${LABEL[$c]%%:*}")"
+        items+=",\"hint\":$(json_str "$( [[ "${LABEL[$c]}" == *:* ]] && echo "${LABEL[$c]#*: }")")"
+        items+=",\"kind\":\"$kind\",\"parent\":$(json_str "$parent")"
+        items+=",\"on\":$( [[ "$now" == 1 ]] && echo true || echo false)"
+        items+=",\"wanted\":$( [[ "${WANTED[$c]:-0}" == 1 ]] && echo true || echo false)"
+        items+=",\"update\":$(feature_outdated "$c" && echo true || echo false)"
+        items+=",\"new\":$(feature_new "$c" && echo true || echo false)"
+        items+=",\"selectable\":$(component_selectable "$c" && echo true || echo false)"
+        # Why it can't be turned on, for the app's explanation.
+        [[ "$c" == vram && -n "${VRAM_NVIDIA_CASE:-}" ]] &&
+            items+=",\"note\":$(json_str "$(vram_nvidia_note "$VRAM_NVIDIA_CASE")")"
+        items+="}"
+    done
+    local cec="" f
+    for f in /dev/cec*; do [[ -e "$f" ]] && cec+="${cec:+ }$(basename "$f")"; done
+    local bios='null'
+    if bios_available; then
+        bios="{\"current\":$(json_str "$(bios_current)"),\"newest\":$(json_str "${BIOS_NEWEST:-}"),\"selectable\":$(bios_selectable && echo true || echo false),\"dryRun\":$([[ -n "$BIOS_DRY_RUN" ]] && echo true || echo false)}"
+    fi
+    printf '{"version":%s,"firstRun":%s,"steamMachine":%s,"kernel":%s,"pinnedKernel":%s,"cecDevices":%s,"leds":%s,"bios":%s,"items":[%s]}\n' \
+        "$(json_str "$VERSION")" "$first_run" \
+        "$(detect_valve_fremont && echo true || echo false)" \
+        "$(json_str "$(uname -r)")" "$(json_str "${PINNED_KERNEL_VER:-}")" \
+        "$(json_str "$cec")" \
+        "$(compgen -G '/sys/class/leds/valve-leds*' | wc -l)" \
+        "$bios" "$items"
+}
+
+backend_run_component() {
+    # backend_run_component <id> <enable|disable>: runs it in this shell
+    # (its variables, e.g. RESTART_FOR_LOGIN, must survive), each output line
+    # as a log event.
+    local c="$1" what="$2" rc
+    backend_event start "\"id\":$(json_str "$c"),\"action\":\"$what\",\"label\":$(json_str "${LABEL[$c]%%:*}")"
+    "${c}_${what}" > >(while IFS= read -r line; do backend_event log "\"id\":$(json_str "$c"),\"line\":$(json_str "$line")"; done) 2>&1
+    rc=$?
+    # Let the log reader finish before the next event.
+    wait $! 2>/dev/null
+    backend_event "done" "\"id\":$(json_str "$c"),\"ok\":$([[ $rc -eq 0 ]] && echo true || echo false)"
+    return $rc
+}
+
+backend_sudo() {
+    # sudo from the app has no terminal: ask through its helper, and keep the
+    # credentials fresh as the menu does.
+    if [[ -z "${SUDO_ASKPASS:-}" ]] && ! sudo -n true 2>/dev/null; then
+        backend_event finished '"failed":[],"restart":false,"error":"no-sudo"'
+        return 1
+    fi
+    sudo() { command sudo ${SUDO_ASKPASS:+-A} "$@"; }
+    if ! sudo -n true 2>/dev/null && ! sudo true 2>/dev/null; then
+        backend_event finished '"failed":[],"restart":false,"error":"wrong-password"'
+        return 1
+    fi
+    while true; do sudo -n true; sleep 50; kill -0 "$$" 2>/dev/null || exit; done 2>/dev/null &
+}
+
+backend_bios_prepare() {
+    # Download, checksum and fwupd's device check; the app then shows its
+    # two warnings and calls bios-flash.
+    local rc
+    backend_sudo || return 1
+    backend_event start '"id":"bios","action":"prepare","label":"Update BIOS"'
+    bios_prepare > >(while IFS= read -r line; do backend_event log "\"id\":\"bios\",\"line\":$(json_str "$line")"; done) 2>&1
+    rc=$?; wait $! 2>/dev/null
+    case $rc in
+        0) backend_event bios-ready "\"current\":$(json_str "$(bios_current)"),\"newest\":$(json_str "$BIOS_NEWEST"),\"checksum\":true,\"compatible\":$(json_str "$BIOS_COMPATIBLE")" ;;
+        2) backend_event finished '"failed":[],"restart":false,"nothing":true' ;;
+        *) backend_event finished '"failed":["bios"],"restart":false' ;;
+    esac
+}
+
+backend_bios_flash() {
+    backend_sudo || return 1
+    local rc
+    backend_run_component bios flash_only; rc=$?
+    backend_event finished "\"failed\":$([[ $rc -eq 0 ]] && echo '[]' || echo '["bios"]'),\"restart\":$(restart_needed && echo true || echo false),\"bios\":true"
+}
+
+backend_apply() {
+    local reapply=false boot="" id c
+    local -a want=()
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --reapply) reapply=true ;;
+            --boot) boot="$2"; shift ;;
+            *) want+=("$1") ;;
+        esac
+        shift
+    done
+    detect_components
+    # What the app ticked: exactly these on, every other component off.
+    for c in "${COMPONENTS[@]}"; do
+        component_available "$c" || continue
+        is_action "$c" && { WANTED[$c]=0; continue; }
+        WANTED[$c]=0
+        for id in "${want[@]}"; do [[ "$id" == "$c" ]] && WANTED[$c]=1; done
+    done
+    # The same rules as the menu's toggles.
+    [[ "${WANTED[single]:-0}" == 1 ]] && WANTED[gaming]=1
+    [[ "${WANTED[gaming]:-0}" == 0 ]] && { WANTED[single]=0; WANTED[boot]=0; }
+    [[ "${WANTED[poweroff]:-0}" == 1 ]] && WANTED[machine]=1
+    [[ "${WANTED[machine]:-0}" == 0 ]] && WANTED[poweroff]=0
+    [[ "${WANTED[kpin]:-0}" == 1 ]] && WANTED[machine]=1
+    [[ "${WANTED[machine]:-0}" == 0 ]] && WANTED[kpin]=0
+    # Retired: only ever removed.
+    WANTED[hdmi]=0
+    case "$boot" in desktop) WANTED[boot]=1; WANTED[gaming]=1 ;; gamescope) WANTED[boot]=0 ;; esac
+
+    REAPPLY=$reapply
+    plan_changes
+    backend_event plan "\"disable\":$(json_list "${TO_DISABLE[@]}"),\"enable\":$(json_list "${TO_ENABLE[@]}")"
+    if [[ ${#TO_DISABLE[@]} -eq 0 && ${#TO_ENABLE[@]} -eq 0 ]]; then
+        feature_record_unticked
+        backend_event finished '"failed":[],"restart":false,"nothing":true'
+        return 0
+    fi
+
+    backend_sudo || return 1
+
+    LOGIN_MANAGER=plasmalogin
+    [[ "${WANTED[single]}" == 1 ]] && LOGIN_MANAGER=sddm
+    local -a failed=()
+    for c in "${TO_DISABLE[@]}"; do
+        if backend_run_component "$c" disable; then feature_record "$c" disable; else failed+=("$c"); fi
+    done
+    for c in "${TO_ENABLE[@]}"; do
+        if backend_run_component "$c" enable; then is_action "$c" || feature_record "$c" enable; else failed+=("$c"); fi
+    done
+    feature_record_unticked
+    [[ " ${TO_DISABLE[*]} ${TO_ENABLE[*]} " =~ \ (gaming|single|boot|kpin)\  ]] && RESTART_FOR_LOGIN=true
+    backend_event finished "\"failed\":$(json_list "${failed[@]}"),\"restart\":$(restart_needed && echo true || echo false)"
+}
+
+backend_main() {
+    case "${1:-}" in
+        status) backend_status ;;
+        apply) shift; backend_apply "$@" ;;
+        bios-prepare) backend_bios_prepare ;;
+        bios-flash) backend_bios_flash ;;
+        *) err "Usage: steamify.sh --backend status | apply [--reapply] [--boot gamescope|desktop] <id>..."; return 2 ;;
+    esac
+}

lib/bios.sh

@@ -121,54 +121,102 @@ bios_fits_device() {
     grep -q '"Guid"' <<< "$details" && ! grep -q '"UpdateError"' <<< "$details"
 }
 
-bios_enable() {
+# The checked firmware waits here between bios_prepare and bios_flash, so the
+# app can show its warnings in between (and the terminal flow uses it too).
+BIOS_STAGE_DIR="${XDG_RUNTIME_DIR:-/tmp}/steamify-bios"
+
+bios_prepare() {
+    # Downloads Valve's package, checks its SHA-256 and extracts the .cab to
+    # $BIOS_STAGE_DIR, then asks fwupd whether it fits this machine. Sets
+    # BIOS_COMPATIBLE (yes|dry-run). 0 = ready to flash, 2 = nothing to do
+    # (already the newest), 1 = error (nothing was touched).
     if ! bios_lookup_newest; then
         err "Couldn't find the newest Steam Machine BIOS on Valve's mirror ($VALVE_MIRROR)."
         return 1
     fi
-    local current tmp compatible
-    current="$(bios_current)"
     [[ -n "$BIOS_DRY_RUN" ]] && warn "DRY RUN (WIZARD_BIOS_DRY_RUN): nothing will be flashed."
-    if [[ "$current" == "$BIOS_NEWEST" ]]; then
-        ok "The BIOS is already the newest version ($current); nothing to do."
-        return 0
+    if [[ "$(bios_current)" == "$BIOS_NEWEST" ]]; then
+        ok "The BIOS is already the newest version ($BIOS_NEWEST); nothing to do."
+        return 2
     fi
-
-    # Download and check everything before asking: the warnings only come
-    # when the file is Valve's (SHA-256 from Valve's repo database) and fwupd
-    # confirms it's firmware for this very machine.
     pacman -Q fwupd >/dev/null 2>&1 || sudo pacman -S --needed --noconfirm fwupd ||
         { err "Installing fwupd failed."; return 1; }
-    tmp="$(mktemp -d)"
+    rm -rf "$BIOS_STAGE_DIR"; mkdir -p "$BIOS_STAGE_DIR"; chmod 700 "$BIOS_STAGE_DIR"
     info "Downloading $BIOS_PKG ($BIOS_REPO)..."
-    if ! curl -fsSL "$VALVE_MIRROR/$BIOS_REPO/os/x86_64/$BIOS_PKG" -o "$tmp/pkg.tar.zst" ||
-        ! echo "$BIOS_SHA256  $tmp/pkg.tar.zst" | sha256sum -c --quiet - ||
-        ! tar -I unzstd -xf "$tmp/pkg.tar.zst" -C "$tmp" "$BIOS_CAB"; then
+    if ! curl -fsSL "$VALVE_MIRROR/$BIOS_REPO/os/x86_64/$BIOS_PKG" -o "$BIOS_STAGE_DIR/pkg.tar.zst" ||
+        ! echo "$BIOS_SHA256  $BIOS_STAGE_DIR/pkg.tar.zst" | sha256sum -c --quiet - ||
+        ! tar -I unzstd -xf "$BIOS_STAGE_DIR/pkg.tar.zst" -C "$BIOS_STAGE_DIR" "$BIOS_CAB"; then
         err "Downloading or verifying $BIOS_PKG failed; the BIOS was not touched."
-        rm -rf "$tmp"
+        rm -rf "$BIOS_STAGE_DIR"
         return 1
     fi
     ok "Checksum OK: this is Valve's $BIOS_PKG."
-    local yes="$c_green$c_bold" b="$c_bold" n="$c_reset"
     if [[ -n "$BIOS_DRY_RUN" ]]; then
         warn "Dry run: skipping fwupd's check that the firmware fits this machine."
-        compatible="${c_yellow}${b}not checked${n} (dry run)"
-    elif bios_fits_device "$tmp/$BIOS_CAB"; then
+        BIOS_COMPATIBLE=dry-run
+    elif bios_fits_device "$BIOS_STAGE_DIR/$BIOS_CAB"; then
         ok "fwupd confirms BIOS $BIOS_NEWEST is firmware for this machine."
-        compatible="${yes}yes${n} (checked by fwupd)"
+        BIOS_COMPATIBLE=yes
     else
         err "fwupd says BIOS $BIOS_NEWEST is not for this machine's hardware; not installing it."
-        rm -rf "$tmp"
+        rm -rf "$BIOS_STAGE_DIR"
         return 1
     fi
+    printf '%s\n' "$BIOS_NEWEST" "$BIOS_CAB" > "$BIOS_STAGE_DIR/ready"
+}
 
+bios_flash() {
+    # Hands the firmware bios_prepare checked to fwupd; it is written during
+    # the next restart. Sets BIOS_NEEDS_RESTART.
+    local newest cab
+    { read -r newest; read -r cab; } < "$BIOS_STAGE_DIR/ready" 2>/dev/null
+    if [[ -z "${cab:-}" || ! -f "$BIOS_STAGE_DIR/$cab" ]]; then
+        err "No checked BIOS file waiting; nothing was flashed."
+        return 1
+    fi
+    if [[ -n "$BIOS_DRY_RUN" ]]; then
+        ok "Dry run: would run: fwupdmgr install -y --no-reboot-check $(basename "$cab")"
+        ok "Dry run finished; nothing was flashed."
+        # Treated as staged, so the restart choices that follow a real
+        # update show up too; restarting only prints (see restart_now).
+        BIOS_NEEDS_RESTART=1
+        rm -rf "$BIOS_STAGE_DIR"
+        return 0
+    fi
+    info "Handing BIOS $newest to fwupd. Do NOT turn off the power from now on."
+    # -y: the user confirmed twice; --no-reboot-check: our own restart
+    # question comes at the end.
+    if ! sudo fwupdmgr install -y --no-reboot-check "$BIOS_STAGE_DIR/$cab"; then
+        err "fwupd could not install the BIOS update (see above); the BIOS was not changed."
+        rm -rf "$BIOS_STAGE_DIR"
+        return 1
+    fi
+    rm -rf "$BIOS_STAGE_DIR"
+    BIOS_NEEDS_RESTART=1
+    ok "BIOS $newest is staged. It is written during the next restart:"
+    warn "keep the power on and don't touch the machine until it has fully started again."
+}
+
+bios_enable() {
+    local rc current compatible
+    current="$(bios_current)"
+    bios_prepare; rc=$?
+    [[ $rc -eq 2 ]] && return 0
+    [[ $rc -ne 0 ]] && return 1
+
+    local yes="$c_green$c_bold" b="$c_bold" n="$c_reset"
+    if [[ "$BIOS_COMPATIBLE" == dry-run ]]; then
+        compatible="${c_yellow}${b}not checked${n} (dry run)"
+    else
+        compatible="${yes}yes${n} (checked by fwupd)"
+    fi
     bios_disclaimer "WARNING: BIOS UPDATE - ENTIRELY AT YOUR OWN RISK" \
         "Current BIOS: ${b}$current${n}" \
         "New BIOS:     ${b}$BIOS_NEWEST${n}" \
         "Checksum:     ${yes}OK${n} (Valve's package)" \
         "Compatible:   $compatible"
     if ! ask_yn "Do you understand the risks and want to continue?" n; then
-        info "BIOS update cancelled; nothing was changed."; rm -rf "$tmp"; return 0
+        info "BIOS update cancelled; nothing was changed."; rm -rf "$BIOS_STAGE_DIR"; return 0
     fi
     bios_disclaimer "LAST CHANCE: THIS FLASHES BIOS $BIOS_NEWEST" \
         "After this, keep the power on until the machine has fully" \
@@ -176,28 +224,10 @@ bios_enable() {
     local reply
     read -rp "$(echo -e "${c_red}${c_bold}Type UPDATE (in capitals) to flash the BIOS, anything else cancels:${c_reset} ")" reply
     if [[ "$reply" != UPDATE ]]; then
-        info "BIOS update cancelled; nothing was changed."; rm -rf "$tmp"; return 0
+        info "BIOS update cancelled; nothing was changed."; rm -rf "$BIOS_STAGE_DIR"; return 0
     fi
-
-    if [[ -n "$BIOS_DRY_RUN" ]]; then
-        ok "Dry run: would run: fwupdmgr install -y --no-reboot-check $(basename "$BIOS_CAB")"
-        ok "Dry run finished; nothing was flashed."
-        # Treated as staged, so the restart choices that follow a real
-        # update show up too; restarting only prints (see restart_now).
-        BIOS_NEEDS_RESTART=1
-        rm -rf "$tmp"
-        return 0
-    fi
-    info "Handing BIOS $BIOS_NEWEST to fwupd. Do NOT turn off the power from now on."
-    # -y: we already asked twice; --no-reboot-check: the wizard's own
-    # restart question comes at the end.
-    if ! sudo fwupdmgr install -y --no-reboot-check "$tmp/$BIOS_CAB"; then
-        err "fwupd could not install the BIOS update (see above); the BIOS was not changed."
-        rm -rf "$tmp"
-        return 1
-    fi
-    rm -rf "$tmp"
-    BIOS_NEEDS_RESTART=1
-    ok "BIOS $BIOS_NEWEST is staged. It is written during the next restart:"
-    warn "keep the power on and don't touch the machine until it has fully started again."
+    bios_flash
 }
+
+# For the app (lib/backend.sh): the flash step alone, after its warnings.
+bios_flash_only() { bios_flash; }

lib/boot-session.sh

@@ -23,19 +23,7 @@ boot_enable() {
     # the session into the base config; run it right away rather than rely
     # on its path unit, which could still be pending when the login manager
     # starts.
-    sudo tee "$BOOT_UNIT" > /dev/null << EOF
-[Unit]
-Description=Steamify CachyOS: boot into the desktop instead of gaming mode
-Before=display-manager.service sddm.service plasmalogin.service
-
-[Service]
-Type=oneshot
-ExecStart=/usr/lib/steamos/steam-set-session plasma.desktop
-ExecStart=/bin/sh -c '[ -x $SESSION_SYNC ] && exec $SESSION_SYNC || true'
-
-[Install]
-WantedBy=graphical.target
-EOF
+    service_file "$BOOT_UNIT_NAME" SESSION_SYNC="$SESSION_SYNC" | sudo tee "$BOOT_UNIT" > /dev/null
     sudo systemctl daemon-reload
     sudo systemctl enable "$BOOT_UNIT_NAME" || { err "Enabling $BOOT_UNIT_NAME failed."; return 1; }
     ok "Boots into the desktop from the next boot on (Return to Gaming Mode still works)."

lib/cec.sh

@@ -3,14 +3,29 @@
 # volume control (cec-audio-control) and the units that attach USB CEC
 # adapters (Pulse-Eight, RainShadow) with inputattach. They're only in
 # Valve's SteamOS (holo) repository, not in CachyOS or the AUR. Works with
-# any /dev/cec*: a GPU with CEC (e.g. the Steam Machine) or a USB adapter.
-# On a Steam Machine, steamos-manager configures cecd from Steam's settings.
+# any /dev/cec*: a GPU with CEC or a USB adapter. On a Steam Machine it also
+# builds Valve's CEC driver (see cec_driver_enable), and steamos-manager
+# configures cecd from Steam's settings.
 # Sourced by steamify.sh; not meant to be run on its own.
 
 CEC_PKGS=(cecd cec-audio-control inputattach-cec-units)
 # steamos-manager checks once, at its start, whether cecd runs; order it
 # after cecd so it never misses it at login.
 CEC_ORDER_DROPIN=/etc/systemd/user/steamos-manager.service.d/10-steamify-after-cecd.conf
+# CachyOS's gaming mode script exports STEAM_ENABLE_CEC=0, which hides
+# Steam's HDMI-CEC settings; Steam reads it from the gamescope environment
+# file. A later EnvironmentFile= overrides it.
+CEC_STEAM_ENV=/etc/steamify/steam-cec.env
+CEC_STEAM_DROPIN=/etc/systemd/user/steam-launcher.service.d/10-steamify-cec.conf
+# The Steam Machine's CEC runs through its embedded controller (cros_ec_cec).
+# Mainline's driver doesn't list Fremont, so there's no /dev/cec0; Valve's
+# kernel does. We build Valve's copy with DKMS for every kernel, pinned to a
+# reviewed commit.
+CEC_DKMS_NAME=steamify-cros-ec-cec
+CEC_DKMS_VER=1
+CEC_DKMS_SRC="/usr/src/$CEC_DKMS_NAME-$CEC_DKMS_VER"
+CEC_DRIVER_URL="https://raw.githubusercontent.com/evlaV/linux-integration/10c8c8800ccd3ae359203b4eefb6479f613b3b8e/drivers/media/cec/platform/cros-ec/cros-ec-cec.c"
+CEC_DRIVER_SHA256=e89fd4e87fceb32d713ffc59b64794779b3c2b3c012b0e2f2e9f0c40b42f4373
 
 cec_link_steamos_manager() {
     # On a Steam Machine: steamos-manager writes cecd's config from Steam's
@@ -27,7 +42,63 @@ cec_link_steamos_manager() {
     return 0
 }
 
-cec_status() { pacman -Q "${CEC_PKGS[@]}" >/dev/null 2>&1; }
+cec_installed() { pacman -Q "${CEC_PKGS[@]}" >/dev/null 2>&1; }
+cec_driver_ok() { ! detect_valve_fremont || [[ -d "$CEC_DKMS_SRC" ]]; }
+# On = installed, Steam told to show its CEC settings and, on a Steam
+# Machine, the driver built. An install from before 1.1.3 (settings) or
+# 2.0.3 (driver) lacks one; the menu then ticks it (see cec_repair).
+cec_status() { cec_installed && [[ -f "$CEC_STEAM_DROPIN" ]] && cec_driver_ok; }
+
+cec_reload_driver() {
+    # cecd keeps /dev/cec0 open, so the old module can't be unloaded under it.
+    systemctl --user stop cecd.service 2>/dev/null
+    sudo modprobe -r cros_ec_cec 2>/dev/null
+    sudo modprobe cros_ec_cec 2>/dev/null
+    systemctl --user start cecd.service 2>/dev/null
+}
+
+cec_driver_enable() {
+    detect_valve_fremont || return 0
+    local tmp k
+    if ! pacman -Q dkms patch >/dev/null 2>&1; then
+        sudo pacman -S --needed --noconfirm dkms patch || { err "Installing dkms failed."; return 1; }
+    fi
+    install_kernel_headers || return 1
+    tmp="$(mktemp -d)"
+    info "Downloading Valve's Steam Machine CEC driver..."
+    if ! curl -fsL "$CEC_DRIVER_URL" -o "$tmp/cros-ec-cec.c" ||
+        ! echo "$CEC_DRIVER_SHA256  $tmp/cros-ec-cec.c" | sha256sum -c --quiet -; then
+        rm -rf "$tmp"
+        err "Downloading Valve's CEC driver failed (or its checksum didn't match)."
+        return 1
+    fi
+    # So it finds amdgpu's HDMI port (see the patch for why).
+    patch_file cros-ec-cec-single-port.patch | patch -s -d "$tmp" -p1 ||
+        { rm -rf "$tmp"; err "Patching Valve's CEC driver failed."; return 1; }
+    echo 'obj-m += cros-ec-cec.o' >"$tmp/Makefile"
+    patch_file "$CEC_DKMS_NAME.dkms.conf" | fill NAME="$CEC_DKMS_NAME" VERSION="$CEC_DKMS_VER" >"$tmp/dkms.conf"
+    sudo dkms remove "$CEC_DKMS_NAME/$CEC_DKMS_VER" --all >/dev/null 2>&1
+    sudo rm -rf "$CEC_DKMS_SRC"
+    sudo install -d "$CEC_DKMS_SRC" && sudo install -m644 "$tmp"/{cros-ec-cec.c,Makefile,dkms.conf} "$CEC_DKMS_SRC/"
+    rm -rf "$tmp"
+    sudo dkms add "$CEC_DKMS_NAME/$CEC_DKMS_VER" >/dev/null || { err "Adding the CEC driver to DKMS failed."; return 1; }
+    # Every kernel with headers; one that fails to build only lacks CEC.
+    for k in /usr/lib/modules/*/build; do
+        k="$(basename "$(dirname "$k")")"
+        info "Building the CEC driver for $k..."
+        sudo dkms install "$CEC_DKMS_NAME/$CEC_DKMS_VER" -k "$k" >/dev/null ||
+            warn "Building the CEC driver for $k failed; that kernel has no HDMI-CEC."
+    done
+    cec_reload_driver
+}
+
+cec_driver_disable() {
+    [[ -d "$CEC_DKMS_SRC" ]] || return 0
+    sudo dkms remove "$CEC_DKMS_NAME/$CEC_DKMS_VER" --all >/dev/null 2>&1
+    sudo rm -rf "$CEC_DKMS_SRC"
+    cec_reload_driver
+}
+cec_repair() { cec_installed && ! cec_status; }
 
 fetch_holo_pkg() {
     # fetch_holo_pkg <dir> <package>: download the newest <package> from
@@ -70,6 +141,7 @@ cec_enable() {
         return 1
     fi
     rm -rf "$tmp"
+    cec_driver_enable || return 1
     # Its udev rule gives the user /dev/cec*; cecd starts with the graphical
     # session, after steamos-manager wrote its config from Steam's settings.
     sudo udevadm control --reload
@@ -77,11 +149,17 @@ cec_enable() {
     sudo mkdir -p "$(dirname "$CEC_ORDER_DROPIN")"
     printf '%s\n' "# Written by Steamify: steamos-manager only sees cecd if it runs at its start." \
         '[Unit]' 'After=cecd.service' | sudo tee "$CEC_ORDER_DROPIN" >/dev/null
+    sudo mkdir -p "$(dirname "$CEC_STEAM_ENV")" "$(dirname "$CEC_STEAM_DROPIN")"
+    printf '%s\n' "# Written by Steamify: Steam's HDMI-CEC settings in gaming mode." 'STEAM_ENABLE_CEC=1' |
+        sudo tee "$CEC_STEAM_ENV" >/dev/null
+    printf '%s\n' "# Written by Steamify: overrides STEAM_ENABLE_CEC=0 from the gaming mode script." \
+        '[Service]' "EnvironmentFile=-$CEC_STEAM_ENV" | sudo tee "$CEC_STEAM_DROPIN" >/dev/null
     systemctl --user daemon-reload
     cec_link_steamos_manager
     if compgen -G "/dev/cec*" >/dev/null; then
         systemctl --user restart cecd.service 2>/dev/null
-        ok "HDMI-CEC on ($(cd /dev && echo cec*)). Turn on CEC on your TV too (e.g. Sony: BRAVIA Sync, Samsung: Anynet+, LG: SimpLink)."
+        ok "HDMI-CEC on ($(cd /dev && echo cec*)); Steam shows its settings from the next gaming mode start."
+        info "Turn on CEC on your TV too (e.g. Sony: BRAVIA Sync, Samsung: Anynet+, LG: SimpLink)."
     else
         warn "No CEC device (/dev/cec*) found: your GPU may not support CEC. A USB CEC adapter"
         warn "(e.g. Pulse-Eight) works too. Check again after a restart with: ls /dev/cec*"
@@ -93,8 +171,9 @@ cec_disable() {
     systemctl --user disable --now cecd.service cec-audio-control.socket cec-audio-control.service 2>/dev/null
     systemctl --user disable steamos-manager-configure-cecd.service 2>/dev/null
     sudo pacman -Rns --noconfirm "${CEC_PKGS[@]}" 2>/dev/null
-    sudo rm -f "$CEC_ORDER_DROPIN"
-    sudo rmdir "$(dirname "$CEC_ORDER_DROPIN")" 2>/dev/null
+    cec_driver_disable
+    sudo rm -f "$CEC_ORDER_DROPIN" "$CEC_STEAM_DROPIN" "$CEC_STEAM_ENV"
+    sudo rmdir "$(dirname "$CEC_ORDER_DROPIN")" "$(dirname "$CEC_STEAM_DROPIN")" "$(dirname "$CEC_STEAM_ENV")" 2>/dev/null
     systemctl --user daemon-reload
     if [[ -n "$(state_get cec installed_linuxconsole)" ]]; then
         sudo pacman -Rns --noconfirm linuxconsole 2>/dev/null

lib/common.sh

@@ -6,6 +6,24 @@ c_reset="\033[0m"; c_bold="\033[1m"; c_green="\033[32m"; c_yellow="\033[33m"; c_
 
 info()  { echo -e "${c_cyan}[INFO]${c_reset} $*"; }
 ok()    { echo -e "${c_green}[OK]${c_reset} $*"; }
+# patch_file <name>: a file from patches/ (module sources, patches). The
+# single-file build replaces this with one that has them embedded.
+patch_file() { cat "$SCRIPT_DIR/patches/$1"; }
+# service_file <name> [KEY=value...]: a systemd unit from services/, filled
+# in. The single-file build replaces service_raw like patch_file.
+service_raw() { cat "$SCRIPT_DIR/services/$1"; }
+service_file() { local name="$1"; shift; service_raw "$name" | fill "$@"; }
+# fill [KEY=value...]: stdin with each @KEY@ replaced by its value, taken
+# literally (a home folder may contain sed's "&", "\" or "|").
+fill() {
+    local kv v
+    local -a subst=(-e '')
+    for kv in "$@"; do
+        v="${kv#*=}"; v="${v//\\/\\\\}"; v="${v//&/\\&}"; v="${v//|/\\|}"
+        subst+=(-e "s|@${kv%%=*}@|$v|g")
+    done
+    sed "${subst[@]}"
+}
 warn()  { echo -e "${c_yellow}[WARN]${c_reset} $*"; }
 err()   { echo -e "${c_red}[ERROR] $*${c_reset}" >&2; }
 ask_yn() {

lib/fremont-poweroff.sh

@@ -0,0 +1,67 @@
+#!/bin/bash
+# "Power-off fix" menu item (poweroff), a sub-option of Steam Machine support
+# ticked along with it (opt-out): the Steam Machine powers off instead of
+# booting up again. Recent kernels (7.2, and the 6.x, 7.0 and 7.1 updates
+# that got the change backported) keep the S4/S5 wake bit the firmware
+# leaves set on GPIO pin 18 ("pinctrl-amd: Don't clear S4 wake bits at
+# probe"), so the machine starts again right after powering off. Valve's kernel clears it at probe on Fremont, in
+# a patch not meant for upstream, so CachyOS won't get it. A small module
+# (patches/steamify-fremont-poweroff.c) clears it right before power-off;
+# DKMS builds it for each installed kernel. On a kernel that clears it
+# itself it does nothing.
+# Sourced by steamify.sh; not meant to be run on its own.
+
+POWEROFF_DKMS_NAME=steamify-fremont-poweroff
+POWEROFF_DKMS_VER=1
+POWEROFF_DKMS_SRC="/usr/src/$POWEROFF_DKMS_NAME-$POWEROFF_DKMS_VER"
+POWEROFF_MODULES_LOAD=/etc/modules-load.d/steamify-fremont-poweroff.conf
+
+poweroff_fix_installed() { [[ -f "$POWEROFF_DKMS_SRC/dkms.conf" && -f "$POWEROFF_MODULES_LOAD" ]]; }
+
+poweroff_fix_enable() {
+    detect_valve_fremont || return 0
+    local tmp k
+    if ! pacman -Q dkms >/dev/null 2>&1; then
+        sudo pacman -S --needed --noconfirm dkms || { err "Installing dkms failed."; return 1; }
+    fi
+    install_kernel_headers || return 1
+    tmp="$(mktemp -d)"
+    patch_file "$POWEROFF_DKMS_NAME.c" > "$tmp/$POWEROFF_DKMS_NAME.c"
+    echo "obj-m += $POWEROFF_DKMS_NAME.o" >"$tmp/Makefile"
+    patch_file "$POWEROFF_DKMS_NAME.dkms.conf" | fill NAME="$POWEROFF_DKMS_NAME" VERSION="$POWEROFF_DKMS_VER" >"$tmp/dkms.conf"
+    sudo dkms remove "$POWEROFF_DKMS_NAME/$POWEROFF_DKMS_VER" --all >/dev/null 2>&1
+    sudo rm -rf "$POWEROFF_DKMS_SRC"
+    sudo install -d "$POWEROFF_DKMS_SRC" &&
+        sudo install -m644 "$tmp"/{"$POWEROFF_DKMS_NAME.c",Makefile,dkms.conf} "$POWEROFF_DKMS_SRC/"
+    rm -rf "$tmp"
+    sudo dkms add "$POWEROFF_DKMS_NAME/$POWEROFF_DKMS_VER" >/dev/null ||
+        { err "Adding the power-off fix to DKMS failed."; return 1; }
+    for k in /usr/lib/modules/*/build; do
+        k="$(basename "$(dirname "$k")")"
+        info "Building the power-off fix for $k..."
+        sudo dkms install "$POWEROFF_DKMS_NAME/$POWEROFF_DKMS_VER" -k "$k" >/dev/null ||
+            warn "Building the power-off fix for $k failed; with that kernel it may start again after shutting down."
+    done
+    echo "$POWEROFF_DKMS_NAME" | sudo tee "$POWEROFF_MODULES_LOAD" >/dev/null
+    sudo modprobe "$POWEROFF_DKMS_NAME" 2>/dev/null
+    return 0
+}
+
+poweroff_fix_disable() {
+    sudo rm -f "$POWEROFF_MODULES_LOAD"
+    sudo modprobe -r "$POWEROFF_DKMS_NAME" 2>/dev/null
+    [[ -d "$POWEROFF_DKMS_SRC" ]] || return 0
+    sudo dkms remove "$POWEROFF_DKMS_NAME/$POWEROFF_DKMS_VER" --all >/dev/null 2>&1
+    sudo rm -rf "$POWEROFF_DKMS_SRC"
+}
+
+poweroff_status() { poweroff_fix_installed; }
+poweroff_enable() {
+    info "Installing the power-off fix (the machine stays off after shutting down)..."
+    poweroff_fix_enable || { err "Installing the power-off fix failed."; return 1; }
+    ok "Power-off fix on: the Steam Machine stays off after shutting down."
+}
+poweroff_disable() {
+    poweroff_fix_disable
+    ok "Power-off fix removed; with recent kernels the Steam Machine may start again after shutting down."
+}

lib/hdmi-refresh.sh

@@ -0,0 +1,103 @@
+#!/bin/bash
+# "HDMI refresh boost" menu item (hdmi), retired in 2.2.0: it saved an EDID
+# override per display (with a hotplug script loading it) so the pinned
+# 7.1.6 kernel ran HDMI displays above 60 Hz. Newer kernels read the whole
+# EDID themselves, and the kernel pin is gone with the power-off fix, so
+# only its removal is left: shown while anything of it is on the system,
+# always unticked, so a normal run removes it.
+# Sourced by steamify.sh; not meant to be run on its own.
+
+HDMI_FW_DIR=/usr/lib/firmware/edid
+# Before 2.1.0 the override was on the kernel command line.
+HDMI_INITRAMFS_CONF=/etc/mkinitcpio.conf.d/90-steamify-edid.conf
+# The saved displays; their EDIDs are $HDMI_FW_DIR/steamify-<id>.bin.
+HDMI_MAP=/etc/steamify/hdmi-edid.conf
+HDMI_RUN=/run/steamify-edid
+HDMI_HOTPLUG=/usr/local/bin/steamify-edid-hotplug
+HDMI_UNIT_NAME=steamify-edid.service
+HDMI_UNIT="/etc/systemd/system/$HDMI_UNIT_NAME"
+HDMI_UDEV_RULE=/etc/udev/rules.d/90-steamify-edid.rules
+
+hdmi_connectors() {
+    # Connected HDMI outputs, as "<card>-<connector>" (e.g. card1-HDMI-A-1).
+    local d
+    for d in /sys/class/drm/card*-HDMI-A-*; do
+        [[ "$(cat "$d/status" 2>/dev/null)" == connected ]] && basename "$d"
+    done
+}
+
+hdmi_boot_file() {
+    # The file holding the kernel command line, per boot loader.
+    if [[ -f /etc/default/limine ]]; then echo /etc/default/limine
+    elif [[ -f /etc/sdboot-manage.conf ]] && command -v sdboot-manage >/dev/null; then echo /etc/sdboot-manage.conf
+    elif [[ -f /etc/default/grub ]]; then echo /etc/default/grub
+    fi
+}
+
+hdmi_cmdline_param() {
+    # The drm.edid_firmware= value we set, or nothing.
+    local f; f="$(hdmi_boot_file)"
+    [[ -n "$f" ]] && grep -oE 'drm\.edid_firmware=[^ "]*steamify-[^ "]*' "$f" 2>/dev/null | head -n 1
+}
+
+hdmi_available() { detect_valve_fremont && hdmi_status; }
+
+hdmi_status() {
+    # On while anything of it is left: saved displays, the hotplug script,
+    # an EDID file, or the kernel parameter of versions before 2.1.0.
+    [[ -s "$HDMI_MAP" || -f "$HDMI_UNIT" || -n "$(hdmi_cmdline_param)" ]] ||
+        compgen -G "$HDMI_FW_DIR/steamify-*.bin" >/dev/null
+}
+
+hdmi_reset_live() {
+    # Puts a connected display back on its own EDID right away. debugfs is
+    # root-only, so the glob runs under sudo; the kernel takes exactly
+    # "reset", without a newline.
+    local d
+    d="$(sudo sh -c 'for d in /sys/kernel/debug/dri/*/"$1"; do [ -e "$d/edid_override" ] && { echo "$d"; break; }; done' _ "${1#card*-}")"
+    [[ -n "$d" ]] || return 1
+    printf reset | sudo tee "$d/edid_override" >/dev/null &&
+        echo 1 | sudo tee "$d/trigger_hotplug" >/dev/null
+}
+
+hdmi_remove_boot_param() {
+    # Removes the drm.edid_firmware= older versions put on the kernel command
+    # line, then rebuilds the initramfs and boot entries.
+    local f
+    [[ -n "$(hdmi_cmdline_param)" ]] || { sudo rm -f "$HDMI_INITRAMFS_CONF"; return 0; }
+    f="$(hdmi_boot_file)"
+    backup_file "$f"
+    sudo sed -i -E 's/drm\.edid_firmware=[^ "]*steamify-[^ "]* ?//' "$f"
+    sudo rm -f "$HDMI_INITRAMFS_CONF"
+    info "Rebuilding the initramfs and boot entries..."
+    case "$f" in
+        /etc/default/limine) sudo limine-mkinitcpio ;;
+        /etc/sdboot-manage.conf) sudo /usr/bin/mkinitcpio -P && sudo sdboot-manage gen ;;
+        /etc/default/grub) sudo /usr/bin/mkinitcpio -P && sudo grub-mkconfig -o /boot/grub/grub.cfg ;;
+    esac
+}
+
+hdmi_forget_all() {
+    # Every saved display and the hotplug script that loaded their EDIDs.
+    local conn
+    sudo rm -f "$HDMI_FW_DIR"/steamify-*.bin
+    sudo systemctl disable "$HDMI_UNIT_NAME" >/dev/null 2>&1
+    sudo rm -f "$HDMI_UDEV_RULE" "$HDMI_UNIT" "$HDMI_HOTPLUG" "$HDMI_MAP"
+    sudo rm -rf "$HDMI_RUN"
+    sudo systemctl daemon-reload
+    sudo udevadm control --reload
+    for conn in $(hdmi_connectors); do hdmi_reset_live "$conn" 2>/dev/null; done
+    return 0
+}
+
+hdmi_enable() {
+    err "HDMI refresh boost is no longer offered: current kernels run HDMI displays at their full rate."
+    return 1
+}
+
+hdmi_disable() {
+    hdmi_forget_all
+    hdmi_remove_boot_param || return 1
+    state_clear hdmi
+    ok "HDMI refresh boost removed; displays use their own EDID again."
+}

lib/login-manager.sh

@@ -185,24 +185,7 @@ install_session_sync() {
     local SYNC_SCRIPT="/usr/local/bin/sync-steamos-session.sh"
     info "Installing session sync bridge at $SYNC_SCRIPT"
 
-    sudo tee "$SYNC_SCRIPT" > /dev/null << 'EOF'
-#!/bin/bash
-SRC="/etc/plasmalogin.conf.d/zz-steamos-autologin.conf"
-DEST="/etc/plasmalogin.conf"
-
-[[ -f "$SRC" ]] || exit 0
-SESSION=$(grep -oP '^Session=\K.*' "$SRC")
-[[ -z "$SESSION" ]] && exit 0
-
-# Only touch Session= inside [Autologin]; other sections may have their own.
-if sed -n '/^\[Autologin\]/,/^\[/p' "$DEST" | grep -q '^Session='; then
-    sed -i "/^\[Autologin\]/,/^\[/ s|^Session=.*|Session=$SESSION|" "$DEST"
-elif grep -q '^\[Autologin\]' "$DEST"; then
-    sed -i "/^\[Autologin\]/a Session=$SESSION" "$DEST"
-else
-    printf '\n[Autologin]\nSession=%s\n' "$SESSION" >> "$DEST"
-fi
-EOF
+    patch_file sync-steamos-session.sh | sudo tee "$SYNC_SCRIPT" > /dev/null
 
     sudo chmod +x "$SYNC_SCRIPT"
     ok "Sync script installed."
@@ -211,28 +194,9 @@ EOF
     # 7. systemd path watcher + service
     info "Installing systemd path watcher so session switches take effect immediately"
 
-    sudo tee /etc/systemd/system/sync-steamos-session.path > /dev/null << 'EOF'
-[Unit]
-Description=Watch for steamos session changes
+    service_file sync-steamos-session.path | sudo tee /etc/systemd/system/sync-steamos-session.path > /dev/null
 
-[Path]
-PathModified=/etc/plasmalogin.conf.d/zz-steamos-autologin.conf
-
-[Install]
-WantedBy=multi-user.target
-EOF
-
-    sudo tee /etc/systemd/system/sync-steamos-session.service > /dev/null << 'EOF'
-[Unit]
-Description=Sync steamos session selection into plasmalogin.conf
-# Session switches can come in bursts (switch + autologin reset); never
-# let systemd's start rate limit silently stop the bridge.
-StartLimitIntervalSec=0
-
-[Service]
-Type=oneshot
-ExecStart=/usr/local/bin/sync-steamos-session.sh
-EOF
+    service_file sync-steamos-session.service | sudo tee /etc/systemd/system/sync-steamos-session.service > /dev/null
 
     sudo systemctl daemon-reload
     sudo systemctl enable --now sync-steamos-session.path

lib/menu.sh

@@ -5,17 +5,30 @@
 
 # Menu order. Components are turned on in this order and off in reverse;
 # gaming must come first (single user builds on it).
-COMPONENTS=(gaming boot theme glyphs single launcher cec machine kpin bios)
+COMPONENTS=(gaming boot theme glyphs single launcher steamgame notify vram cec machine poweroff kpin hdmi bios)
 # One-off actions rather than on/off components: never preselected, never
 # re-applied, not listed as on or off.
 ACTIONS=(bios)
 # Sub-options, shown indented under their parent and only while it's ticked.
-declare -A PARENT=([boot]=gaming [kpin]=machine)
+declare -A PARENT=([boot]=gaming [steamgame]=launcher [poweroff]=machine [kpin]=machine [hdmi]=machine [bios]=machine)
 # Never preselected on a first run: booting into the desktop is a choice,
 # gamescope is the default; HDMI-CEC is opt-in (it can wake the machine or
 # upset other devices on the TV, even on SteamOS), except on a Steam Machine,
-# which has CEC like on SteamOS.
-NO_PRESELECT=(boot cec)
+# which has CEC like on SteamOS. HDMI refresh boost needs someone at the
+# screen to confirm each step.
+NO_PRESELECT=(boot cec kpin hdmi)
+# Feature versions: the Steamify version in which what a component's enable
+# sets up last changed; set it to the new VERSION whenever you change one.
+# Each successful run records it (state "features"); a component that's on
+# with an older one is ticked and re-applied by a normal run, and the app
+# shows it as an update. A setup from before these were recorded counts as
+# FEATURE_BASELINE.
+FEATURE_BASELINE=2.1.0
+declare -A FEATURE_VERSION=(
+    [gaming]=2.1.0 [boot]=2.1.0 [theme]=2.1.0 [glyphs]=2.1.0 [single]=2.1.0
+    [launcher]=2.1.0 [cec]=2.1.0 [machine]=2.2.0 [poweroff]=2.2.0 [vram]=2.3.0 [notify]=2.5.0 [steamgame]=2.5.1
+    [kpin]=2.1.0 [hdmi]=2.1.0
+)
 
 declare -A LABEL=(
     [gaming]="SteamOS conversion: boot into gaming mode, Steam on the desktop"
@@ -23,17 +36,26 @@ declare -A LABEL=(
     [theme]="Install SteamOS theme: Vapor look (cachyos-vapor)"
     [glyphs]="Install Steam Deck/Machine icons: Deck button icons in gaming mode"
     [single]="Single user mode: no password, lock screen or log out (SDDM)"
-    [launcher]="Steamify shortcut: desktop icon to run this again"
+    [launcher]="Steamify shortcut: the app on the desktop, Steamify Terminal in the launcher"
+    [steamgame]="Add as non-Steam game: Steamify in your Steam library, for the controller and gaming mode"
+    [notify]="Update notifications: a notification when there's a new Steamify, never updates by itself"
+    [vram]="VRAM booster: the game in front keeps its VRAM, background apps make room"
     [cec]="HDMI-CEC: use Steam with the TV remote, TV on/off with the PC (experimental)"
     [machine]="Steam Machine support: LED bar driver, hardware settings in Steam"
-    [kpin]="Pin the kernel to $PINNED_KERNEL_VER (fixes rebooting after shutdown)"
+    [poweroff]="Power-off fix: the Steam Machine stays off after shutting down"
+    [kpin]="Pin the kernel to $PINNED_KERNEL_VER (untick for CachyOS's current kernel)"
+    [hdmi]="HDMI refresh boost: highest refresh your HDMI display runs"
     [bios]="Update BIOS"
 )
 declare -A CURRENT WANTED
 
 component_available() {
     case "$1" in
-        machine|kpin) machine_available ;;
+        machine|poweroff) machine_available ;;
+        vram) vram_available ;;
+        steamgame) steamgame_available ;;
+        kpin) kpin_available ;;
+        hdmi) hdmi_available ;;
         bios) bios_available ;;
     esac
 }
@@ -53,10 +75,67 @@ menu_visible() {
     [[ -z "${PARENT[$1]:-}" || "${WANTED[${PARENT[$1]}]:-0}" == 1 ]]
 }
 
+feature_record_unticked() {
+    # After a run the user confirmed: options shown but left unticked that
+    # have no record yet count as turned off, or the next run would offer a
+    # default one again as "new" (feature_new) and tick it: e.g. single user
+    # mode unticked on a first run came back ticked when anything else
+    # changed. Hidden sub-options weren't a choice, so they're left alone.
+    local c
+    for c in "${COMPONENTS[@]}"; do
+        is_action "$c" && continue
+        menu_visible "$c" || continue
+        [[ "${WANTED[$c]:-0}" == 0 && -z "$(state_get features "$c")" ]] && state_set features "$c" off
+    done
+    return 0
+}
+
+feature_record() {
+    # feature_record <component> <enable|disable>: after a successful run.
+    if [[ "$2" == enable ]]; then state_set features "$1" "${FEATURE_VERSION[$1]:-$FEATURE_BASELINE}"
+    else state_set features "$1" off; fi
+}
+
+feature_outdated() {
+    # On, but set up by an older version of that feature (compared as
+    # versions: 2.10.0 is newer than 2.9.0).
+    local have want
+    [[ "${CURRENT[$1]:-0}" == 1 ]] || return 1
+    have="$(state_get features "$1" "$FEATURE_BASELINE")"
+    [[ "$have" == off ]] && have="$FEATURE_BASELINE"
+    want="${FEATURE_VERSION[$1]:-$FEATURE_BASELINE}"
+    [[ "$have" != "$want" && "$(printf '%s\n' "$have" "$want" | sort -V | head -n 1)" == "$have" ]]
+}
+
+menu_label() {
+    # The label, with "(update)" after the name when a newer version of it
+    # will be applied, "(new)" for a default sub-option added since the
+    # last run.
+    local l="${LABEL[$1]}" b=""
+    if feature_outdated "$1"; then b="${c_yellow}(update)${c_reset}"
+    elif feature_new "$1"; then b="${c_green}(new)${c_reset}"; fi
+    if [[ -n "$b" ]]; then
+        if [[ "$l" == *:* ]]; then l="${l%%:*} $b:${l#*:}"
+        else l+=" $b"; fi
+    fi
+    printf '%s' "$l"
+}
+
+feature_new() {
+    # A default option added after its parent was set up (e.g. the power-off
+    # fix under Steam Machine support; a top-level one counts the SteamOS
+    # conversion as its parent): never turned on or off.
+    local p="${PARENT[$1]:-gaming}"
+    [[ "$1" != gaming && "${CURRENT[$p]:-0}" == 1 && "${CURRENT[$1]:-0}" == 0 ]] &&
+        ! is_action "$1" && component_selectable "$1" && [[ " ${NO_PRESELECT[*]} " != *" $1 "* ]] &&
+        [[ -z "$(state_get features "$1")" ]]
+}
+
 component_selectable() {
     # Greyed out and not tickable when it has nothing to do.
     case "$1" in
         bios) bios_selectable ;;
+        vram) vram_selectable ;;
     esac
 }
 
@@ -67,12 +146,33 @@ detect_components() {
         if "${c}_status"; then CURRENT[$c]=1; any=true; else CURRENT[$c]=0; fi
         WANTED[$c]=${CURRENT[$c]}
     done
+    # HDMI-CEC set up by an older version: tick it, so a normal run fixes it.
+    component_available cec && cec_repair && WANTED[cec]=1
+    # Updated features and new default sub-options: ticked, so a normal run
+    # applies them.
+    for c in "${COMPONENTS[@]}"; do
+        component_available "$c" || continue
+        { feature_outdated "$c" || feature_new "$c"; } && WANTED[$c]=1
+    done
+    # The kernel pin is no longer needed (the power-off fix), and HDMI
+    # refresh boost needed the pin: whatever is left of either is unticked,
+    # so a normal run removes it.
+    component_available kpin && WANTED[kpin]=0
+    component_available hdmi && WANTED[hdmi]=0
+    # The terminal-only Steamify shortcut from before 2.0.1: tick it, so a
+    # normal run replaces it with the app.
+    launcher_repair && WANTED[launcher]=1
     # Shows the current and newest BIOS version.
     bios_available && { bios_lookup_newest; LABEL[bios]="$(bios_label)"; }
+    # Greyed out with an NVIDIA card: say why, and what to do.
+    if component_available vram && ! vram_selectable; then
+        VRAM_NVIDIA_CASE="$(vram_nvidia_case)"
+        LABEL[vram]="VRAM booster: $(vram_nvidia_hint "$VRAM_NVIDIA_CASE")"
+    fi
     # First run: preselect the full SteamOS experience (never an action).
     if [[ "$any" == false ]]; then
         for c in "${COMPONENTS[@]}"; do
-            component_available "$c" && ! is_action "$c" &&
+            component_available "$c" && component_selectable "$c" && ! is_action "$c" &&
                 [[ " ${NO_PRESELECT[*]} " != *" $c "* ]] && WANTED[$c]=1
         done
         machine_available && WANTED[cec]=1
@@ -88,9 +188,16 @@ toggle_component() {
     if [[ "$c" == gaming && "${WANTED[gaming]}" == 0 ]]; then WANTED[single]=0; WANTED[boot]=0; fi
     # Where to boot to is part of the conversion, too.
     if [[ "$c" == boot && "${WANTED[boot]}" == 1 ]]; then WANTED[gaming]=1; fi
-    # The kernel pin is opt-out: ticked along with Steam Machine support.
-    if [[ "$c" == machine ]]; then WANTED[kpin]=${WANTED[machine]}; fi
+    # The power-off fix is opt-out: ticked along with Steam Machine support.
+    if [[ "$c" == machine ]]; then WANTED[poweroff]=${WANTED[machine]}; fi
+    if [[ "$c" == poweroff && "${WANTED[poweroff]}" == 1 ]]; then WANTED[machine]=1; fi
+    if [[ "$c" == machine && "${WANTED[machine]}" == 0 ]]; then WANTED[kpin]=0; WANTED[bios]=0; fi
     if [[ "$c" == kpin && "${WANTED[kpin]}" == 1 ]]; then WANTED[machine]=1; fi
+    if [[ "$c" == bios && "${WANTED[bios]}" == 1 ]]; then WANTED[machine]=1; fi
+    # Steam starts Steamify through the shortcut's start script.
+    # Opt-out, like the power-off fix: ticked along with the shortcut.
+    if [[ "$c" == launcher ]] && component_available steamgame; then WANTED[steamgame]=${WANTED[launcher]}; fi
+    if [[ "$c" == steamgame && "${WANTED[steamgame]}" == 1 ]]; then WANTED[launcher]=1; fi
 }
 
 show_menu() {
@@ -113,12 +220,13 @@ show_menu() {
             [[ "${CURRENT[gaming]}" == 1 ]] || now="-"
             want="gaming"; [[ "${WANTED[boot]}" == 1 ]] && want="desk"
             printf "  %-3s %-6s %-6s   └ %s\n" "$i" "$now" "$want" "$(boot_choice "${WANTED[boot]}")"
+        elif ! component_selectable "$c"; then
+            local tree=""; [[ -n "${PARENT[$c]:-}" ]] && tree="  └ "
+            printf "  %b%-3s %-6s %-6s %s%s (not available)%b\n" "$c_dim" "$i" "$now" "$want" "$tree" "${LABEL[$c]}" "$c_reset"
         elif [[ -n "${PARENT[$c]:-}" ]]; then
-            printf "  %-3s %b %-6s   └ %s\n" "$i" "$now" "$want" "${LABEL[$c]}"
-        elif component_selectable "$c"; then
-            printf "  %-3s %b %-6s %s\n" "$i" "$now" "$want" "${LABEL[$c]}"
+            printf "  %-3s %b %-6s   └ %b\n" "$i" "$now" "$want" "$(menu_label "$c")"
         else
-            printf "  %b%-3s %-6s %-6s %s (not available)%b\n" "$c_dim" "$i" "$now" "$want" "${LABEL[$c]}" "$c_reset"
+            printf "  %-3s %b %-6s %b\n" "$i" "$now" "$want" "$(menu_label "$c")"
         fi
     done
     echo
@@ -166,8 +274,9 @@ draw_menu_tui() {
         fi
         if ! component_selectable "$c"; then
             # Greyed out: nothing to do (e.g. BIOS already up to date).
-            local mark="   "; (( i == cursor )) && mark=" ${c_cyan}>${c_reset} "
-            echo -e "${mark}${c_dim}[ ] ${LABEL[$c]}  (not available)${c_reset}"
+            local mark="   " tree=""; (( i == cursor )) && mark=" ${c_cyan}>${c_reset} "
+            [[ -n "${PARENT[$c]:-}" ]] && tree="    └ "
+            echo -e "${mark}${c_dim}${tree}[ ] ${LABEL[$c]}  (not available)${c_reset}"
         elif (( i == cursor )); then
             # The green x's reset would end the bold too: re-enable it after.
             echo -e " ${c_cyan}>${c_reset} ${c_bold}${line//"$c_reset"/"$c_reset$c_bold"}${c_reset}${state}"
@@ -250,7 +359,7 @@ plan_changes() {
         component_available "$c" || continue
         [[ "${WANTED[$c]}" == 1 ]] || continue
         if is_action "$c"; then TO_ENABLE+=("$c"); continue; fi
-        if [[ "${CURRENT[$c]}" == 0 || "$REAPPLY" == true ]] ||
+        if [[ "${CURRENT[$c]}" == 0 || "$REAPPLY" == true ]] || feature_outdated "$c" ||
             [[ "$c" == gaming && "${CURRENT[single]}" != "${WANTED[single]}" ]]; then
             TO_ENABLE+=("$c")
         fi
@@ -265,13 +374,14 @@ apply_changes() {
     for c in "${TO_DISABLE[@]}"; do
         if [[ "$c" == boot ]]; then echo; echo -e "${c_bold}Boot into: gamescope${c_reset}"
         else echo; echo -e "${c_bold}Turning off: ${LABEL[$c]}${c_reset}"; fi
-        "${c}_disable" || failed+=("$c")
+        if "${c}_disable"; then feature_record "$c" disable; else failed+=("$c"); fi
     done
     for c in "${TO_ENABLE[@]}"; do
         if [[ "$c" == boot ]]; then echo; echo -e "${c_bold}Boot into: desktop${c_reset}"
         elif is_action "$c"; then echo; echo -e "${c_bold}Running: ${LABEL[$c]%%:*}${c_reset}"
         else echo; echo -e "${c_bold}Turning on: ${LABEL[$c]}${c_reset}"; fi
-        "${c}_enable" || failed+=("$c")
+        if "${c}_enable"; then is_action "$c" || feature_record "$c" enable; else failed+=("$c"); fi
     done
+    feature_record_unticked
     FAILED=("${failed[@]}")
 }

lib/single-user.sh

@@ -81,6 +81,13 @@ single_wallet_disable() {
     ok "Your own wallet is back (the empty one is kept as kdewallet.kwl$WALLET_OURS)."
 }
 
+reload_screen_locker() {
+    # The screen locker only reads kscreenlockerrc when the session starts:
+    # without this it keeps locking after idling until the next login.
+    qdbus6 org.freedesktop.ScreenSaver /ScreenSaver org.kde.screensaver.configure >/dev/null 2>&1 ||
+        busctl --user call org.freedesktop.ScreenSaver /ScreenSaver org.kde.screensaver configure >/dev/null 2>&1 || true
+}
+
 single_launcher() {
     # Launcher: only Sleep / Restart / Shut Down, no Session dropdown (where
     # Log Out lives). Restricting action/logout instead would also hide
@@ -114,6 +121,7 @@ single_enable() {
     single_launcher
 
     restart_plasmashell_if_stopped
+    reload_screen_locker
     single_wallet_enable
     ok "Single user: no lock screen, user switching or log out."
 }
@@ -143,6 +151,7 @@ single_disable() {
         done
     fi
     restart_plasmashell_if_stopped
+    reload_screen_locker
     single_wallet_disable
     ok "KDE's normal lock screen and user switching are back."
 }

lib/state.sh

@@ -5,7 +5,11 @@
 # deletes the key if it didn't exist before).
 # Sourced by steamify.sh; not meant to be run on its own.
 
-STATE_DIR="${XDG_STATE_HOME:-$HOME/.local/state}/cachyos-gamescope-boot"
+STATE_DIR="${XDG_STATE_HOME:-$HOME/.local/state}/steamify"
+# Steamify's own files in the home folder: the app (app/, from
+# steamify-app.sh) and the shortcut's and notifier's scripts (bin/).
+STEAMIFY_DATA="${XDG_DATA_HOME:-$HOME/.local/share}/steamify"
+STEAMIFY_BIN="$STEAMIFY_DATA/bin"
 UNSET=$'\x01'
 
 kset() {
@@ -77,3 +81,57 @@ state_clear() {
 current_display_manager() {
     systemctl show -p Id --value display-manager 2>/dev/null | sed 's/\.service$//'
 }
+
+migrate_dir() {
+    # migrate_dir <old> <new>: moves <old> to <new> and leaves a symlink.
+    # When both exist (an older release ran after a newer one), what <new>
+    # lacks is moved over; a file in both keeps <new>'s copy and <old> stays
+    # as it is. Returns 0 when something moved.
+    local old="$1" new="$2" f moved=1
+    [[ -d "$old" && ! -L "$old" ]] || return 1
+    if [[ ! -e "$new" ]]; then
+        mkdir -p "$(dirname "$new")"
+        mv "$old" "$new" && ln -s "$new" "$old"
+        return 0
+    fi
+    for f in "$old"/* "$old"/.[!.]*; do
+        [[ -e "$f" || -L "$f" ]] || continue
+        [[ -e "$new/${f##*/}" ]] && continue
+        mv "$f" "$new/" && moved=0
+    done
+    rmdir "$old" 2>/dev/null && ln -s "$new" "$old"
+    return "$moved"
+}
+
+migrate_layout() {
+    # Before 2.5.0 the state and scripts were under the project's old name
+    # (cachyos-gamescope-boot). Moved once; the old names stay as symlinks,
+    # so an older release that still runs finds the same state.
+    local old_state="${XDG_STATE_HOME:-$HOME/.local/state}/cachyos-gamescope-boot"
+    local old_bin="${XDG_DATA_HOME:-$HOME/.local/share}/cachyos-gamescope-boot"
+    local old_icon="${XDG_DATA_HOME:-$HOME/.local/share}/icons/hicolor/scalable/apps/cachyos-gamescope-boot-wizard.svg"
+    local f
+    # Links left pointing at nothing once their component was turned off.
+    for f in "$old_state" "$old_bin"; do [[ -L "$f" && ! -e "$f" ]] && rm -f "$f"; done
+    migrate_dir "$old_state" "$STATE_DIR"
+    if migrate_dir "$old_bin" "$STEAMIFY_BIN"; then
+        # The notifier had the old paths built in; its unit and the
+        # shortcut's entries point at the scripts.
+        [[ -f "$STEAMIFY_BIN/steamify-notifier" ]] &&
+            patch_file steamify-notifier.py | install_executable "$STEAMIFY_BIN/steamify-notifier" 755
+        for f in "$NOTIFY_UNITS/$NOTIFY_NAME.service" "$WIZARD_APP_ENTRY" "$WIZARD_TERMINAL_ENTRY" \
+            "$(wizard_desktop_dir)/$WIZARD_DESKTOP_NAME"; do
+            [[ -f "$f" ]] && sed -i "s|$old_bin/|$STEAMIFY_BIN/|g" "$f"
+        done
+        systemctl --user daemon-reload 2>/dev/null
+    fi
+    if [[ -f "$old_icon" ]]; then
+        if [[ -e "$WIZARD_ICON" ]]; then rm -f "$old_icon"; else mv "$old_icon" "$WIZARD_ICON"; fi
+        gtk-update-icon-cache -q -f -t "$(dirname "$(dirname "$(dirname "$WIZARD_ICON")")")" 2>/dev/null || true
+    fi
+    for f in "$WIZARD_APP_ENTRY" "$WIZARD_TERMINAL_ENTRY" "$(wizard_desktop_dir)/$WIZARD_DESKTOP_NAME"; do
+        [[ -f "$f" ]] && grep -q '^Icon=cachyos-gamescope-boot-wizard$' "$f" &&
+            sed -i 's|^Icon=cachyos-gamescope-boot-wizard$|Icon=steamify|' "$f"
+    done
+    return 0
+}

lib/steam-desktop.sh

@@ -16,23 +16,7 @@ steam_enable() {
     systemd_user_dir="$HOME/.config/systemd/user"
     mkdir -p "$systemd_user_dir"
 
-    cat << 'EOF' > "$systemd_user_dir/steam-desktop-autostart.service"
-[Unit]
-Description=Steam Background Autostart for Virtual Keyboard
-After=graphical-session.target
-PartOf=graphical-session.target
-
-[Service]
-Type=simple
-# Only in the Plasma desktop session; gamescope-session starts its own Steam.
-ExecCondition=/bin/sh -c '[ "$XDG_CURRENT_DESKTOP" = KDE ]'
-ExecStart=/usr/bin/steam -silent
-Restart=on-failure
-RestartSec=5
-
-[Install]
-WantedBy=graphical-session.target
-EOF
+    service_file steam-desktop-autostart.service > "$systemd_user_dir/steam-desktop-autostart.service"
 
     # Clean out old .desktop shortcut so they don't fight
     rm -f "$HOME/.config/autostart/steam.desktop"

lib/steam-game.sh

@@ -0,0 +1,133 @@
+#!/bin/bash
+# "Add as non-Steam game" (steamgame), a sub-option of the Steamify shortcut:
+# Steamify CachyOS in the Steam library, so Steam can start it: with Steam
+# Input it then gets the controller (a Steam Controller only talks to Steam
+# while Steam runs), in gaming mode too. Steam reads its non-Steam games
+# (userdata/<id>/config/shortcuts.vdf, binary; patches/steam-shortcuts.py)
+# only at startup and writes them back on exit, so Steam is closed for the
+# edit and started again. That's refused while a Steam session depends on it:
+# in gaming mode, or with this run started from Steam itself. What it did is
+# recorded per Steam account (state steamgame, "<account>": "<appid> added"
+# or "<appid> updated", for an entry that was there already): Steam rewrites
+# the file on exit, so a mark inside the entry could be lost; the start
+# script's path in it is the other sign it's ours.
+# Sourced by steamify.sh; not meant to be run on its own.
+
+STEAM_ROOT="${XDG_DATA_HOME:-$HOME/.local/share}/Steam"
+STEAMGAME_NAME="Steamify CachyOS"
+# Steam shows no SVG icons: the shortcut's icon rendered as PNG.
+STEAMGAME_ICON="$STEAMIFY_DATA/steamify.png"
+
+steamgame_files() {
+    # Every Steam account's shortcuts.vdf (the file may not exist yet).
+    local d
+    for d in "$STEAM_ROOT"/userdata/*/config; do
+        [[ -d "$d" && "$(basename "$(dirname "$d")")" != 0 ]] && echo "$d/shortcuts.vdf"
+    done
+}
+
+steamgame_tool() {
+    python3 <(patch_file steam-shortcuts.py) "$@"
+}
+
+steamgame_available() { [[ -n "$(steamgame_files)" ]]; }
+
+steamgame_status() {
+    local f
+    while IFS= read -r f; do
+        [[ -f "$f" ]] && steamgame_tool find "$f" "$WIZARD_APP_LAUNCHER" >/dev/null && return 0
+    done < <(steamgame_files)
+    return 1
+}
+
+steamgame_steam_busy() {
+    # Closing Steam would end what's running: gaming mode is Steam's own
+    # session, and a run started from Steam is one of its games.
+    if [[ -n "${SteamGameId:-}" ]]; then
+        err "Steamify was started from Steam, which has to close for this. Start it from the desktop icon, or run Steamify Terminal."
+        return 0
+    fi
+    if pgrep -x gamescope >/dev/null || pgrep -f gamescope-session >/dev/null; then
+        err "Steam has to close for this, which would end gaming mode. Do it from the desktop."
+        return 0
+    fi
+    return 1
+}
+
+steamgame_edit() {
+    # steamgame_edit <function>: runs it with Steam closed, then starts Steam
+    # again if it was running (through our autostart unit when that's there).
+    local was_running=false i
+    if pgrep -x steam >/dev/null; then
+        steamgame_steam_busy && return 1
+        was_running=true
+        info "Closing Steam for a moment (it only reads its games list at startup)..."
+        # A Steam that's still starting ignores the request: ask again.
+        for ((i = 0; i < 90; i++)); do
+            ((i % 15 == 0)) && steam -shutdown >/dev/null 2>&1
+            pgrep -x steam >/dev/null || break
+            sleep 1
+        done
+        pgrep -x steam >/dev/null && { err "Steam didn't close; nothing changed."; return 1; }
+    fi
+    "$1"; local rc=$?
+    if [[ "$was_running" == true ]]; then
+        if systemctl --user is-enabled -q steam-desktop-autostart.service 2>/dev/null; then
+            systemctl --user start steam-desktop-autostart.service
+        else
+            systemd-run --user --collect -q steam -silent >/dev/null 2>&1
+        fi
+        info "Steam is starting again."
+    fi
+    return "$rc"
+}
+
+steamgame_icon() {
+    # The PNG, or the SVG when it can't be rendered (librsvg comes with KDE).
+    if [[ -f "$WIZARD_ICON" ]] && command -v rsvg-convert >/dev/null &&
+        mkdir -p "$STEAMIFY_DATA" && rsvg-convert -w 256 -h 256 -o "$STEAMGAME_ICON" "$WIZARD_ICON" 2>/dev/null; then
+        echo "$STEAMGAME_ICON"
+    else
+        echo "$WIZARD_ICON"
+    fi
+}
+
+steamgame_add_all() {
+    local f out icon
+    icon="$(steamgame_icon)"
+    while IFS= read -r f; do
+        # A copy of each account's list before the first change.
+        [[ -f "$f" && ! -f "$STATE_DIR/shortcuts-$(basename "$(dirname "$(dirname "$f")")").vdf" ]] &&
+            mkdir -p "$STATE_DIR" && cp -a "$f" "$STATE_DIR/shortcuts-$(basename "$(dirname "$(dirname "$f")")").vdf"
+        out="$(steamgame_tool add "$f" "$STEAMGAME_NAME" "$WIZARD_APP_LAUNCHER" "$icon" "$WIZARD_APP_ENTRY")" ||
+            { err "Couldn't add Steamify to $f."; return 1; }
+        state_set steamgame "$(basename "$(dirname "$(dirname "$f")")")" "${out#* } ${out%% *}"
+        info "Steam library ($(basename "$(dirname "$(dirname "$f")")")): ${out%% *} $STEAMGAME_NAME."
+    done < <(steamgame_files)
+}
+
+steamgame_remove_all() {
+    local f id
+    while IFS= read -r f; do
+        [[ -f "$f" ]] || continue
+        # Any entry for our start script: it can't start anything without it.
+        while id="$(steamgame_tool find "$f" "$WIZARD_APP_LAUNCHER")"; do
+            steamgame_tool remove "$f" "$id" || return 1
+        done
+    done < <(steamgame_files)
+}
+
+steamgame_enable() {
+    [[ -x "$WIZARD_APP_LAUNCHER" ]] || { err "The Steamify shortcut isn't set up; turn that on first."; return 1; }
+    info "Adding $STEAMGAME_NAME to your Steam library..."
+    steamgame_edit steamgame_add_all || return 1
+    ok "Steamify is in your Steam library (non-Steam games): start it from there for the controller, in gaming mode too."
+}
+
+steamgame_disable() {
+    info "Removing $STEAMGAME_NAME from your Steam library..."
+    steamgame_edit steamgame_remove_all || return 1
+    state_clear steamgame
+    rm -f "$STEAMGAME_ICON"
+    ok "Steamify removed from your Steam library."
+}

lib/steam-machine.sh

@@ -1,6 +1,7 @@
 #!/bin/bash
 # "Steam Machine support" menu item, only on Valve Fremont hardware: the
-# front LED bar driver, LED access for Steam, and steamos-manager.
+# front LED bar driver, LED access for Steam and steamos-manager. Its
+# sub-option "Power-off fix" is lib/fremont-poweroff.sh.
 # Sourced by steamify.sh; not meant to be run on its own.
 
 detect_valve_fremont() {
@@ -14,8 +15,8 @@ detect_valve_fremont() {
         [[ "$vendor" == "OEM" && "$product" == "F7F" ]]
 }
 
-# Kernel pinned on a Steam Machine: with newer linux-cachyos releases it
-# reboots instead of shutting down. The packages are kept in
+# Kernel pinned on a Steam Machine (optional): newer linux-cachyos releases
+# rebooted it instead of shutting down, which the power-off fix now handles. The packages are kept in
 # PINNED_KERNEL_DIR, so re-applying (or reinstalling after an update slipped
 # through) needs no download.
 PINNED_KERNEL_VER="7.1.6-1"
@@ -148,7 +149,9 @@ remove_kernel_pin() {
     RESTART_FOR_LOGIN=true
 }
 
-# "Pin the kernel" menu item, a sub-option of Steam Machine support.
+# "Pin the kernel" menu item, a sub-option of Steam Machine support. The
+# power-off fix made it unnecessary: only shown while on, to remove it.
+kpin_available() { detect_valve_fremont && kpin_status; }
 kpin_status() {
     pinned_kernel_installed && grep -Eq '^IgnorePkg\s*=.*\slinux-cachyos(\s|$)' /etc/pacman.conf
 }
@@ -163,7 +166,12 @@ kpin_enable() {
     fi
 }
 
-kpin_disable() { remove_kernel_pin; }
+kpin_disable() {
+    # Saved HDMI refresh boost EDIDs were for the pinned kernel only (newer
+    # ones read the whole EDID), also those of displays not connected now.
+    hdmi_status && hdmi_forget_all
+    remove_kernel_pin
+}
 
 install_kernel_headers() {
     # DKMS can only build leds-valve against kernels whose headers are
@@ -216,9 +224,11 @@ install_valve_led_driver() {
     # a clang-built tree). DKMS reads this override after the package's
     # dkms.conf; written before the install so its own build works too.
     # On a fresh system dkms isn't installed yet, so /etc/dkms doesn't exist.
+    # Someone's own override is backed up and kept, with ours after it: it's
+    # sourced as bash, so our MAKE[0] wins.
     sudo mkdir -p "$(dirname "$LED_DKMS_OVERRIDE")"
-    if ! printf '%s\n' "# Written by cachyos-gamescope-boot: build for DKMS's target kernel." \
-        'MAKE[0]="make KVERSION=${kernelver}"' | sudo tee "$LED_DKMS_OVERRIDE" >/dev/null; then
+    if ! led_dkms_override | sudo tee "$LED_DKMS_OVERRIDE.new" >/dev/null ||
+        ! sudo mv -f "$LED_DKMS_OVERRIDE.new" "$LED_DKMS_OVERRIDE"; then
         err "Couldn't write $LED_DKMS_OVERRIDE; without it the LED driver only builds for the running kernel."
         return 1
     fi
@@ -277,7 +287,33 @@ install_valve_led_driver() {
 
 LED_UDEV_RULE="/etc/udev/rules.d/70-valve-leds-user.rules"
 LED_DKMS_OVERRIDE="/etc/dkms/leds-valve-dkms.conf"
-HEADERS_SCRIPT="/usr/local/lib/cachyos-gamescope-boot/ensure-kernel-headers"
+
+led_dkms_override() {
+    # The override to write: an existing one's own lines (backed up the first
+    # time), without ours from an earlier run, then ours. Before 2.5.0 the
+    # file was ours alone, with a different comment.
+    local ours
+    ours="$(patch_file leds-valve-dkms.conf)"
+    if [[ -f "$LED_DKMS_OVERRIDE" ]]; then
+        grep -qxF -f <(echo "$ours") "$LED_DKMS_OVERRIDE" ||
+            grep -q '^# Written by cachyos-gamescope-boot' "$LED_DKMS_OVERRIDE" ||
+            backup_file "$LED_DKMS_OVERRIDE" >&2
+        grep -vxF -f <(echo "$ours") "$LED_DKMS_OVERRIDE" | grep -v '^# Written by cachyos-gamescope-boot'
+    fi
+    echo "$ours"
+}
+
+led_dkms_override_remove() {
+    # Puts someone's own override back, or removes ours.
+    if [[ -f "$LED_DKMS_OVERRIDE.bak-gamescope-wizard" ]]; then
+        sudo mv -f "$LED_DKMS_OVERRIDE.bak-gamescope-wizard" "$LED_DKMS_OVERRIDE"
+    else
+        sudo rm -f "$LED_DKMS_OVERRIDE"
+    fi
+}
+HEADERS_SCRIPT="/usr/local/lib/steamify/ensure-kernel-headers"
+# Before 2.5.0; removed when it's set up again or turned off.
+HEADERS_SCRIPT_OLD="/usr/local/lib/cachyos-gamescope-boot/ensure-kernel-headers"
 HEADERS_UNIT="/etc/systemd/system/ensure-kernel-headers.service"
 
 install_headers_boot_check() {
@@ -287,36 +323,10 @@ install_headers_boot_check() {
     # So check at every boot and install missing headers, which triggers
     # that hook and builds the driver for the new kernel.
     sudo mkdir -p "$(dirname "$HEADERS_SCRIPT")"
-    sudo tee "$HEADERS_SCRIPT" > /dev/null << 'EOF'
-#!/bin/bash
-# Installed by cachyos-gamescope-boot: install missing -headers for every
-# installed kernel, so DKMS builds leds-valve for it.
-set -u
-missing=()
-for k in $(pacman -Qqo /usr/lib/modules/*/pkgbase 2>/dev/null | sort -u); do
-    pacman -Q "${k}-headers" >/dev/null 2>&1 && continue
-    pacman -Si "${k}-headers" >/dev/null 2>&1 && missing+=("${k}-headers")
-done
-[[ ${#missing[@]} -eq 0 ]] && exit 0
-# Another pacman is running (e.g. an update): try again next boot.
-[[ -e /var/lib/pacman/db.lck ]] && { echo "pacman is busy, skipping"; exit 0; }
-echo "Installing missing kernel headers: ${missing[*]}"
-exec pacman -S --needed --noconfirm "${missing[@]}"
-EOF
+    patch_file ensure-kernel-headers.sh | sudo tee "$HEADERS_SCRIPT" > /dev/null
     sudo chmod 755 "$HEADERS_SCRIPT"
-    sudo tee "$HEADERS_UNIT" > /dev/null << EOF
-[Unit]
-Description=Install missing kernel headers so DKMS builds leds-valve for every kernel
-Wants=network-online.target
-After=network-online.target
-
-[Service]
-Type=oneshot
-ExecStart=$HEADERS_SCRIPT
-
-[Install]
-WantedBy=multi-user.target
-EOF
+    sudo rm -rf "$(dirname "$HEADERS_SCRIPT_OLD")"
+    service_file ensure-kernel-headers.service HEADERS_SCRIPT="$HEADERS_SCRIPT" | sudo tee "$HEADERS_UNIT" > /dev/null
     sudo systemctl daemon-reload
     sudo systemctl enable ensure-kernel-headers.service
 }
@@ -329,13 +339,13 @@ reload_powerdevil() {
 kernel_overview() {
     # Per installed kernel: headers (needed to build DKMS modules), the
     # in-kernel Steam controller driver, and, on a Steam Machine, whether the
-    # LED driver is built for it. Printed in the menu so it's easy to verify
+    # LED driver and the power-off fix are built for it. Printed in the menu so it's easy to verify
     # a kernel update or a newly added kernel got everything.
     local mark="${c_green}yes${c_reset}" miss="${c_red}no ${c_reset}" leds=false
     detect_valve_fremont && command -v dkms >/dev/null 2>&1 && leds=true
-    local kdir k pkg headers hid led running line
+    local kdir k pkg headers hid led off running line
     local legend="> = running; controller = Steam controller driver"
-    [[ "$leds" == true ]] && legend+=", LEDs = LED bar driver built"
+    [[ "$leds" == true ]] && legend+=", LEDs = LED bar driver built, power-off = power-off fix built"
     echo -e "  ${c_bold}Kernels${c_reset} ($legend)"
     for kdir in /usr/lib/modules/*/; do
         k="$(basename "$kdir")"
@@ -347,11 +357,12 @@ kernel_overview() {
         line="$(printf '%-23s %-18s headers %b  controller %b' "$k" "$pkg" "$headers" "$hid")"
         if [[ "$leds" == true ]]; then
             led="$miss"; dkms status -k "$k" leds-valve-dkms 2>/dev/null | grep -q installed && led="$mark"
-            line+="$(printf '  LEDs %b' "$led")"
+            off="$miss"; dkms status -k "$k" "$POWEROFF_DKMS_NAME" 2>/dev/null | grep -q installed && off="$mark"
+            line+="$(printf '  LEDs %b  power-off %b' "$led" "$off")"
         fi
         echo -e "  ${running}${line}"
     done
-    cec_status && { echo; echo -e "    $(cec_overview)"; }
+    cec_installed && { echo; echo -e "    $(cec_overview)"; }
     if [[ "$leds" == true ]]; then
         local loaded="$miss" nodes
         lsmod | grep -q '^leds_valve' && loaded="$mark"
@@ -422,8 +433,9 @@ machine_disable() {
     krevert machine
     reload_powerdevil
     sudo systemctl disable ensure-kernel-headers.service 2>/dev/null
-    sudo rm -f "$LED_DKMS_OVERRIDE" "$HEADERS_UNIT" "$HEADERS_SCRIPT"
-    sudo rmdir "$(dirname "$HEADERS_SCRIPT")" 2>/dev/null
+    led_dkms_override_remove
+    sudo rm -f "$HEADERS_UNIT" "$HEADERS_SCRIPT"
+    sudo rm -rf "$(dirname "$HEADERS_SCRIPT")" "$(dirname "$HEADERS_SCRIPT_OLD")"
     sudo systemctl daemon-reload
     ok "Steam Machine support removed (the AUR helper, if installed, is kept)."
 }

lib/update-notifier.sh

@@ -0,0 +1,58 @@
+#!/bin/bash
+# "Update notifications" menu item (notify), ticked by default: a systemd
+# user timer checks GitHub's newest release once a day and at each Plasma
+# login. When it's newer than the last Steamify that ran here, it shows a
+# notification (Open Steamify / Skip this version) and a tray icon until
+# then; it never updates anything itself (patches/steamify-notifier.py).
+# Sourced by steamify.sh; not meant to be run on its own.
+
+NOTIFY_SCRIPT="$STEAMIFY_BIN/steamify-notifier"
+NOTIFY_UNITS="${XDG_CONFIG_HOME:-$HOME/.config}/systemd/user"
+NOTIFY_NAME=steamify-update-check
+
+notify_status() {
+    [[ -f "$NOTIFY_SCRIPT" ]] &&
+        systemctl --user is-enabled -q "$NOTIFY_NAME.timer" 2>/dev/null &&
+        systemctl --user is-enabled -q "$NOTIFY_NAME.service" 2>/dev/null
+}
+
+notify_seen() {
+    # Every run records its version: the notifier compares the newest
+    # release with it, so opening Steamify ends a reminder. Also whether it
+    # was the app or the terminal menu: the notification opens the same.
+    notify_status || return 0
+    state_set notify seen "$VERSION"
+    if [[ "$BACKEND" == true ]]; then state_set notify frontend app; else state_set notify frontend terminal; fi
+}
+
+notify_enable() {
+    local p missing=()
+    info "Adding update notifications..."
+    # PySide6 for the tray icon, notify-send for the notification's buttons.
+    python3 -c 'import PySide6.QtWidgets' 2>/dev/null || missing+=(pyside6)
+    command -v notify-send >/dev/null || missing+=(libnotify)
+    if ((${#missing[@]})); then
+        sudo pacman -S --needed --noconfirm "${missing[@]}" ||
+            { err "Installing ${missing[*]} failed."; return 1; }
+    fi
+    patch_file steamify-notifier.py | install_executable "$NOTIFY_SCRIPT" 755 ||
+        { err "Couldn't write $NOTIFY_SCRIPT."; return 1; }
+    mkdir -p "$NOTIFY_UNITS"
+    service_file "$NOTIFY_NAME.service" NOTIFY_SCRIPT="$NOTIFY_SCRIPT" > "$NOTIFY_UNITS/$NOTIFY_NAME.service"
+    service_file "$NOTIFY_NAME.timer" > "$NOTIFY_UNITS/$NOTIFY_NAME.timer"
+    systemctl --user daemon-reload
+    systemctl --user enable "$NOTIFY_NAME.service" >/dev/null 2>&1 &&
+        systemctl --user enable --now "$NOTIFY_NAME.timer" >/dev/null 2>&1 ||
+        { err "Enabling the update check failed."; return 1; }
+    state_set notify seen "$VERSION"
+    ok "Update notifications on: you'll get a notification when there's a new Steamify."
+}
+
+notify_disable() {
+    systemctl --user disable --now "$NOTIFY_NAME.timer" "$NOTIFY_NAME.service" >/dev/null 2>&1
+    rm -f "$NOTIFY_UNITS/$NOTIFY_NAME.service" "$NOTIFY_UNITS/$NOTIFY_NAME.timer" "$NOTIFY_SCRIPT"
+    rmdir "$STEAMIFY_BIN" 2>/dev/null || true
+    systemctl --user daemon-reload
+    state_clear notify
+    ok "Update notifications off."
+}

lib/vram-booster.sh

@@ -0,0 +1,137 @@
+#!/bin/bash
+# "VRAM booster" menu item (vram), ticked by default, like SteamOS 3.9's
+# dGPU VRAM management: the game in front keeps its VRAM, background apps
+# are evicted first, so a game that needs most of it doesn't spill into
+# system RAM and stutter. The kernel side is the dmem cgroup controller
+# (7.2; amdgpu and xe register their VRAM, NVIDIA's driver doesn't), so it's
+# only offered when the kernel lists a VRAM region (vram or vidmem) of at least 2 GB. CachyOS packages the userspace
+# side: dmemcg-booster (a system service that enables the controller and
+# sets the limits, plus a user service) and plasma-foreground-booster, which
+# tells it which window is in front on the desktop. The latter only starts
+# with "autostart" set in kcgroupsrc.
+# Sourced by steamify.sh; not meant to be run on its own.
+
+VRAM_PKGS=(dmemcg-booster plasma-foreground-booster)
+VRAM_MIN_BYTES=$((2 * 1024 * 1024 * 1024))
+# The regions the kernel's dmem controller lists (a file under /sys/fs/cgroup;
+# a variable so tests can point it at a copy).
+VRAM_CAPACITY="${WIZARD_VRAM_CAPACITY:-/sys/fs/cgroup/dmem.capacity}"
+
+vram_supported() {
+    # WIZARD_VRAM_FAKE_NVIDIA (tests): as with an NVIDIA card whose driver
+    # doesn't register its VRAM; see vram_nvidia_case.
+    [[ -n "${WIZARD_VRAM_FAKE_NVIDIA:-}" ]] && return 1
+    # Only for a GPU with its own VRAM: an integrated GPU registers a small
+    # carve-out too, but mostly uses system RAM, so there's little to boost.
+    # By what the driver registers, not the brand: amdgpu and xe name the
+    # region "vram", other drivers "vidmem" (numbered with several), so an
+    # NVIDIA driver that registers its memory is offered right away.
+    awk -v min="$VRAM_MIN_BYTES" '$1 ~ /\/(vram|vidmem)[0-9]*$/ && $2 >= min { found = 1 } END { exit !found }' \
+        "$VRAM_CAPACITY" 2>/dev/null
+}
+
+vram_nvidia() {
+    # An NVIDIA display controller (PCI vendor 10de, class 03xxxx).
+    local d
+    [[ -n "${WIZARD_VRAM_FAKE_NVIDIA:-}" ]] && return 0
+    for d in /sys/bus/pci/devices/*; do
+        [[ "$(cat "$d/vendor" 2>/dev/null)" == 0x10de && "$(cat "$d/class" 2>/dev/null)" == 0x03* ]] && return 0
+    done
+    return 1
+}
+
+# chwd's lists of NVIDIA cards that need a closed legacy branch (580xx,
+# 470xx, 390xx); every other NVIDIA card runs the open kernel modules.
+VRAM_CHWD_IDS=/var/lib/chwd/ids
+
+vram_nvidia_case() {
+    # Why an NVIDIA card's VRAM isn't registered, so the menu can say what to
+    # do: "update" (open modules older than 615), "switch <chwd profile>"
+    # (closed driver on a card the open one supports), "legacy" (card only
+    # runs a closed legacy branch), "nouveau" (no NVIDIA module).
+    # WIZARD_VRAM_FAKE_NVIDIA=1 fakes "switch nvidia-dkms-580xx", or name a case.
+    local fake="${WIZARD_VRAM_FAKE_NVIDIA:-}" license d id p
+    if [[ -n "$fake" ]]; then
+        [[ "$fake" == 1 ]] && fake="switch nvidia-dkms-580xx"
+        echo "$fake"; return
+    fi
+    license="$(modinfo -F license nvidia 2>/dev/null)"
+    case "$license" in
+        "Dual MIT/GPL") echo update; return ;;
+        "") echo nouveau; return ;;
+    esac
+    for d in /sys/bus/pci/devices/*; do
+        [[ "$(cat "$d/vendor" 2>/dev/null)" == 0x10de && "$(cat "$d/class" 2>/dev/null)" == 0x03* ]] || continue
+        id="$(cat "$d/device")"; id="${id#0x}"
+        grep -qwi "$id" "$VRAM_CHWD_IDS"/nvidia-*.ids 2>/dev/null && { echo legacy; return; }
+    done
+    for p in 580xx 470xx 390xx; do
+        pacman -Q "nvidia-$p-dkms" >/dev/null 2>&1 && { echo "switch nvidia-dkms-$p"; return; }
+    done
+    echo switch
+}
+
+vram_nvidia_hint() {
+    # vram_nvidia_hint <case>: the short reason (terminal menu, the app's row).
+    case "$1" in
+        update) echo "update NVIDIA's driver to 615 or newer (sudo pacman -Syu)" ;;
+        switch*) echo "needs NVIDIA's open driver, which your card supports" ;;
+        legacy) echo "your NVIDIA card's driver doesn't support it (older than RTX 20)" ;;
+        *) echo "the nouveau driver doesn't support it yet" ;;
+    esac
+}
+
+vram_nvidia_note() {
+    # vram_nvidia_note <case>: the full explanation, with what to do.
+    local profile="${1#switch}"; profile="${profile# }"
+    case "$1" in
+        update) echo "NVIDIA's open driver tells Linux how its video memory is used from version 615 on; yours is older ($(cat /sys/module/nvidia/version 2>/dev/null || echo unknown)). Update your system (sudo pacman -Syu), restart, and it's available here." ;;
+        switch*) echo "Your card also runs NVIDIA's open driver, the one CachyOS installs by default, and only that one tells Linux how its video memory is used. You're using NVIDIA's closed driver. Switch in a terminal with: ${profile:+sudo chwd -r $profile && }sudo chwd -i nvidia-open-dkms, then restart: it's available here after that. Steamify doesn't switch it for you: if something goes wrong, the screen stays black after the restart." ;;
+        legacy) echo "Your NVIDIA card is older than the RTX 20 series and only runs NVIDIA's closed driver, which doesn't tell Linux how its video memory is used. Newer NVIDIA cards (RTX 20 series and up), and AMD and Intel graphics cards, support it." ;;
+        *) echo "The open-source nouveau driver doesn't tell Linux how its video memory is used yet (a patch is on its way into the kernel). NVIDIA's own open driver does, from version 615 on (sudo chwd -a installs the right one)." ;;
+    esac
+}
+
+# Shown where it works, and greyed out with an NVIDIA card whose driver
+# doesn't register its VRAM with the kernel (yet): so it's clear why it
+# can't be turned on. Hidden elsewhere (integrated graphics, older kernel).
+vram_available() { vram_supported || vram_status || vram_nvidia; }
+vram_selectable() { vram_supported || vram_status; }
+
+vram_status() {
+    pacman -Q "${VRAM_PKGS[@]}" >/dev/null 2>&1 &&
+        systemctl is-enabled -q dmemcg-booster-system.service 2>/dev/null &&
+        systemctl --user is-enabled -q dmemcg-booster-user.service 2>/dev/null
+}
+
+vram_enable() {
+    local p missing=()
+    info "Installing the VRAM booster (the game in front keeps its VRAM)..."
+    for p in "${VRAM_PKGS[@]}"; do pacman -Q "$p" >/dev/null 2>&1 || missing+=("$p"); done
+    if ((${#missing[@]})); then
+        sudo pacman -S --needed --noconfirm "${missing[@]}" ||
+            { err "Installing ${missing[*]} failed."; return 1; }
+        state_set vram installed_pkgs "${missing[*]}"
+    fi
+    sudo systemctl enable --now dmemcg-booster-system.service >/dev/null 2>&1 ||
+        { err "Starting dmemcg-booster failed."; return 1; }
+    systemctl --user enable --now dmemcg-booster-user.service >/dev/null 2>&1 ||
+        { err "Starting dmemcg-booster for $USER failed."; return 1; }
+    kset vram kcgroupsrc "Foreground Booster" autostart true
+    # Started by the Plasma session from now on; start it in this one too.
+    [[ "${XDG_CURRENT_DESKTOP:-}" == KDE ]] &&
+        systemctl --user start plasma-foreground-booster.service >/dev/null 2>&1
+    ok "VRAM booster on: the game in front keeps its VRAM."
+}
+
+vram_disable() {
+    local pkgs
+    systemctl --user disable --now plasma-foreground-booster.service dmemcg-booster-user.service >/dev/null 2>&1
+    sudo systemctl disable --now dmemcg-booster-system.service >/dev/null 2>&1
+    krevert vram
+    pkgs="$(state_get vram installed_pkgs)"
+    # shellcheck disable=SC2086 # a list of package names
+    [[ -n "$pkgs" ]] && sudo pacman -Rns --noconfirm $pkgs >/dev/null 2>&1
+    state_clear vram
+    ok "VRAM booster off."
+}

lib/wizard-shortcut.sh

@@ -1,19 +1,29 @@
 #!/bin/bash
-# "Steamify shortcut" menu item: a desktop icon and an app launcher entry that
-# open the newest release of Steamify CachyOS in Konsole (curl | bash, like the
-# install command in the README), so it's never out of date.
+# "Steamify shortcut" menu item: "Steamify CachyOS" on the desktop and in the
+# app launcher opens the newest release of the app (curl | bash of
+# steamify-app.sh, like the install command in the README), so it's never out
+# of date; "Steamify Terminal" in the launcher opens the terminal menu in
+# Konsole the same way.
 # Sourced by steamify.sh; not meant to be run on its own.
 
 WIZARD_RELEASE="https://github.com/theupriser/steamify-cachyos/releases/latest/download"
 WIZARD_URL="$WIZARD_RELEASE/steamify.sh"
+WIZARD_APP_URL="$WIZARD_RELEASE/steamify-app.sh"
 # Steam logo with a gear (assets/ in the repo, published with every release).
-WIZARD_ICON="${XDG_DATA_HOME:-$HOME/.local/share}/icons/hicolor/scalable/apps/cachyos-gamescope-boot-wizard.svg"
-WIZARD_LAUNCHER="${XDG_DATA_HOME:-$HOME/.local/share}/cachyos-gamescope-boot/run-wizard"
-WIZARD_DESKTOP_NAME="cachyos-gamescope-boot-wizard.desktop"
-WIZARD_APP_ENTRY="${XDG_DATA_HOME:-$HOME/.local/share}/applications/$WIZARD_DESKTOP_NAME"
+WIZARD_ICON="${XDG_DATA_HOME:-$HOME/.local/share}/icons/hicolor/scalable/apps/steamify.svg"
+WIZARD_LAUNCHER="$STEAMIFY_BIN/run-wizard"
+WIZARD_APP_LAUNCHER="$STEAMIFY_BIN/run-app"
+WIZARD_APPS="${XDG_DATA_HOME:-$HOME/.local/share}/applications"
+# steamify-ui: the id the app gives itself, so its window belongs to this
+# entry. steamify-app.sh leaves an entry with X-Steamify-Shortcut alone.
+WIZARD_DESKTOP_NAME="steamify-ui.desktop"
+WIZARD_APP_ENTRY="$WIZARD_APPS/$WIZARD_DESKTOP_NAME"
+WIZARD_TERMINAL_ENTRY="$WIZARD_APPS/steamify-terminal.desktop"
+# Before 2.0.1 the shortcut opened the terminal menu under this name.
+WIZARD_OLD_NAME="cachyos-gamescope-boot-wizard.desktop"
 
-wizard_desktop_file() {
-    echo "$(xdg-user-dir DESKTOP 2>/dev/null || echo "$HOME/Desktop")/$WIZARD_DESKTOP_NAME"
+wizard_desktop_dir() {
+    xdg-user-dir DESKTOP 2>/dev/null || echo "$HOME/Desktop"
 }
 
 install_executable() {
@@ -29,11 +39,15 @@ install_executable() {
 }
 
 launcher_status() {
-    [[ -x "$WIZARD_LAUNCHER" && -f "$WIZARD_APP_ENTRY" ]]
+    [[ -x "$WIZARD_APP_LAUNCHER" && -x "$WIZARD_LAUNCHER" && -f "$WIZARD_APP_ENTRY" && -f "$WIZARD_TERMINAL_ENTRY" ]]
 }
 
+# A shortcut from before 2.0.1 (terminal only): the menu ticks the item, so a
+# normal run replaces it.
+launcher_repair() { [[ -f "$WIZARD_APPS/$WIZARD_OLD_NAME" ]] && ! launcher_status; }
+
 launcher_enable() {
-    info "Adding the Steamify shortcut (desktop icon and app launcher entry)..."
+    info "Adding the Steamify shortcut (the app on the desktop and in the launcher, Steamify Terminal in the launcher)..."
     install_executable "$WIZARD_LAUNCHER" 755 << EOF
 #!/bin/bash
 # Installed by Steamify CachyOS: run its newest release.
@@ -53,6 +67,23 @@ for (( i = 10; i > 0; i-- )); do
     read -rs -t 1 _ && break
 done
 echo
+EOF
+
+    # The app, without a terminal. Only the first time, when PySide6 still
+    # has to be installed, it runs in Konsole: sudo asks for the password there.
+    install_executable "$WIZARD_APP_LAUNCHER" 755 << EOF
+#!/bin/bash
+# Installed by Steamify CachyOS: start the newest release of its app.
+set -o pipefail
+if [[ "\${1:-}" != --in-terminal ]] && ! python3 -c 'import PySide6.QtQml' 2>/dev/null; then
+    exec konsole -e "\$0" --in-terminal
+fi
+if ! curl -fsSL --max-time 30 "$WIZARD_APP_URL" | bash; then
+    msg="Couldn't download or start Steamify. Are you connected to the internet?"
+    if [[ "\${1:-}" == --in-terminal ]]; then echo; echo "\$msg"; read -rp "Press Enter to close this window... " _
+    else kdialog --title Steamify --sorry "\$msg" 2>/dev/null; fi
+    exit 1
+fi
 EOF
 
     # The icon comes with the release; without it, Steam's own icon.
@@ -60,7 +91,7 @@ EOF
     tmp="$(mktemp)"
     if curl -fsSL --max-time 20 "$WIZARD_RELEASE/steam-gaming-settings.svg" -o "$tmp" && grep -q '<svg' "$tmp"; then
         install -D -m 644 "$tmp" "$WIZARD_ICON"
-        icon=cachyos-gamescope-boot-wizard
+        icon=steamify
         gtk-update-icon-cache -q -f -t "${XDG_DATA_HOME:-$HOME/.local/share}/icons/hicolor" 2>/dev/null || true
     else
         warn "Couldn't download the shortcut's icon; using Steam's icon instead."
@@ -72,18 +103,34 @@ EOF
 Type=Application
 Name=Steamify CachyOS
 Comment=Turn the SteamOS-style parts of this PC on or off
+Exec=$WIZARD_APP_LAUNCHER
+Icon=$icon
+Terminal=false
+Categories=Game;System;Settings;
+X-Steamify-Shortcut=true"
+    printf '%s\n' "$entry" | install_executable "$WIZARD_APP_ENTRY" 644
+    printf '%s\n' "$entry" | install_executable "$(wizard_desktop_dir)/$WIZARD_DESKTOP_NAME" 755
+    printf '%s\n' "[Desktop Entry]
+Type=Application
+Name=Steamify Terminal
+Comment=Steamify CachyOS's menu in a terminal
 Exec=konsole -e $WIZARD_LAUNCHER
 Icon=$icon
 Terminal=false
-Categories=Game;System;Settings;"
-    printf '%s\n' "$entry" | install_executable "$WIZARD_APP_ENTRY" 644
-    printf '%s\n' "$entry" | install_executable "$(wizard_desktop_file)" 755
+Categories=Game;System;Settings;" | install_executable "$WIZARD_TERMINAL_ENTRY" 644
+    # The terminal-only shortcut from before 2.0.1.
+    rm -f "$(wizard_desktop_dir)/$WIZARD_OLD_NAME" "$WIZARD_APPS/$WIZARD_OLD_NAME"
     kbuildsycoca6 >/dev/null 2>&1 || true
-    ok "Steamify shortcut added: \"Steamify CachyOS\" on the desktop and in the launcher."
+    ok "Steamify shortcut added: \"Steamify CachyOS\" (the app) on the desktop and in the launcher, \"Steamify Terminal\" in the launcher."
 }
 
 launcher_disable() {
-    rm -f "$(wizard_desktop_file)" "$WIZARD_APP_ENTRY" "$WIZARD_LAUNCHER" "$WIZARD_ICON"
+    # The launcher entry only if it's ours: steamify-app.sh writes its own
+    # under the same name when there's no shortcut.
+    grep -q '^X-Steamify-Shortcut=true' "$WIZARD_APP_ENTRY" 2>/dev/null && rm -f "$WIZARD_APP_ENTRY"
+    rm -f "$(wizard_desktop_dir)/$WIZARD_DESKTOP_NAME" "$WIZARD_TERMINAL_ENTRY" \
+        "$(wizard_desktop_dir)/$WIZARD_OLD_NAME" "$WIZARD_APPS/$WIZARD_OLD_NAME" \
+        "$WIZARD_LAUNCHER" "$WIZARD_APP_LAUNCHER" "$WIZARD_ICON"
     rmdir "$(dirname "$WIZARD_LAUNCHER")" 2>/dev/null || true
     kbuildsycoca6 >/dev/null 2>&1 || true
     ok "Steamify shortcut removed."

patches/README.md

@@ -0,0 +1,16 @@
+# Patches and extra sources
+
+Files Steamify builds or applies, kept out of the shell code so they can be
+read and reviewed on their own. `lib/*.sh` reads them with `patch_file
+<name>` (piped through `fill KEY=value...` for `@KEY@` placeholders); the single-file build (`.github/tools/bundle.sh`) embeds them.
+
+| File | Used by | What |
+|---|---|---|
+| `steamify-fremont-poweroff.c` | `lib/fremont-poweroff.sh` (Steam Machine support) | Kernel module (DKMS): clears GPIO 18's S4/S5 wake bit before power-off, so the Steam Machine stays off with recent kernels |
+| `sync-steamos-session.sh` | `lib/login-manager.sh` (SteamOS conversion, plasma-login-manager) | The sync bridge: copies Steam's session choice from `zz-steamos-autologin.conf` into `plasmalogin.conf`'s `[Autologin]` |
+| `ensure-kernel-headers.sh` | `lib/steam-machine.sh` (Steam Machine support) | Run at boot: installs missing headers for every installed kernel |
+| `leds-valve-dkms.conf` | `lib/steam-machine.sh` (Steam Machine support) | `/etc/dkms` override: build the LED driver for DKMS's target kernel; appended to someone's own override, which is backed up and restored |
+| `steamify-fremont-poweroff.dkms.conf`, `steamify-cros-ec-cec.dkms.conf` | `lib/fremont-poweroff.sh`, `lib/cec.sh` | The DKMS modules' `dkms.conf` (`fill NAME=... VERSION=...`) |
+| `steam-shortcuts.py` | `lib/steam-game.sh` (Add as non-Steam game) | Reads and writes Steam's binary `shortcuts.vdf` (find, add or update, remove) |
+| `steamify-notifier.py` | `lib/update-notifier.sh` (Update notifications) | The daily check: notification and tray icon when there's a new release |
+| `cros-ec-cec-single-port.patch` | `lib/cec.sh` (HDMI-CEC) | Makes Valve's Steam Machine CEC driver find amdgpu's HDMI port |

patches/cros-ec-cec-single-port.patch

@@ -0,0 +1,21 @@
+Steam Machine CEC: find amdgpu's HDMI port with a single CEC port.
+
+amdgpu registers its HDMI notifier without a port name, which only matches
+the driver's named lookup ("Port C") if the CEC driver loaded first; amdgpu
+loads from the initramfs, so it never does and /dev/cec0 stays at f.f.f.f.
+With a single CEC port, look the notifier up by device alone.
+
+Applies to Valve's drivers/media/cec/platform/cros-ec/cros-ec-cec.c
+(evlaV/linux-integration 10c8c880, see CEC_DRIVER_URL in lib/cec.sh).
+
+--- a/cros-ec-cec.c
++++ b/cros-ec-cec.c
+@@ -485,7 +485,7 @@
+ 		goto out_probe_adapter;
+ 	}
+ 
+-	port->notify = cec_notifier_cec_adap_register(hdmi_dev, conns[port_num],
++	port->notify = cec_notifier_cec_adap_register(hdmi_dev, conns[1] ? conns[port_num] : NULL,
+ 						      port->adap);
+ 	if (!port->notify) {
+ 		ret = -ENOMEM;

patches/ensure-kernel-headers.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+# Installed by Steamify: install missing -headers for every
+# installed kernel, so DKMS builds leds-valve for it.
+set -u
+missing=()
+for k in $(pacman -Qqo /usr/lib/modules/*/pkgbase 2>/dev/null | sort -u); do
+    pacman -Q "${k}-headers" >/dev/null 2>&1 && continue
+    pacman -Si "${k}-headers" >/dev/null 2>&1 && missing+=("${k}-headers")
+done
+[[ ${#missing[@]} -eq 0 ]] && exit 0
+# Another pacman is running (e.g. an update): try again next boot.
+[[ -e /var/lib/pacman/db.lck ]] && { echo "pacman is busy, skipping"; exit 0; }
+echo "Installing missing kernel headers: ${missing[*]}"
+exec pacman -S --needed --noconfirm "${missing[@]}"

patches/leds-valve-dkms.conf

@@ -0,0 +1,2 @@
+# Written by Steamify: build leds-valve for DKMS's target kernel, not the running one.
+MAKE[0]="make KVERSION=${kernelver}"

patches/steam-shortcuts.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python3
+# Steamify CachyOS: Steam's non-Steam games list (userdata/<id>/config/
+# shortcuts.vdf, binary VDF), for "Add as non-Steam game". Steam reads it only
+# at startup and writes it back on exit, so it's edited while Steam is closed.
+#   steam-shortcuts.py find   <vdf> <exe>                  -> appid of an entry for exe
+#   steam-shortcuts.py add    <vdf> <name> <exe> <icon> <desktop file>
+#                                                          -> "added <appid>" / "updated <appid>"
+#   steam-shortcuts.py remove <vdf> <appid>
+# An entry counts as ours when its Exe is <exe>, or a Steamify start script
+# (run-app, also under the pre-2.5.0 path): that one is updated, not doubled.
+import os
+import struct
+import sys
+import zlib
+
+MAP, STR, INT, END = 0, 1, 2, 8
+
+
+def parse(data):
+    pos = 0
+
+    def cstr():
+        nonlocal pos
+        end = data.index(b"\0", pos)
+        s = data[pos:end].decode("utf-8", "surrogateescape")
+        pos = end + 1
+        return s
+
+    def block():
+        nonlocal pos
+        items = []
+        while True:
+            t = data[pos]
+            pos += 1
+            if t == END:
+                return items
+            key = cstr()
+            if t == MAP:
+                items.append((key, block()))
+            elif t == STR:
+                items.append((key, cstr()))
+            elif t == INT:
+                items.append((key, struct.unpack_from("<I", data, pos)[0]))
+                pos += 4
+            else:
+                raise ValueError(f"unknown VDF type {t} at {pos}")
+
+    if not data:
+        return [("shortcuts", [])]
+    root = block()
+    return root
+
+
+def dump(items):
+    out = bytearray()
+    for key, value in items:
+        k = key.encode("utf-8", "surrogateescape") + b"\0"
+        if isinstance(value, list):
+            out += bytes([MAP]) + k + dump(value)
+        elif isinstance(value, int):
+            out += bytes([INT]) + k + struct.pack("<I", value & 0xFFFFFFFF)
+        else:
+            out += bytes([STR]) + k + value.encode("utf-8", "surrogateescape") + b"\0"
+    return bytes(out) + bytes([END])
+
+
+def get(entry, key, default=None):
+    # Steam's key names vary in case between versions (appid/AppName/Exe).
+    for k, v in entry:
+        if k.lower() == key.lower():
+            return v
+    return default
+
+
+def put(entry, key, value):
+    for i, (k, _) in enumerate(entry):
+        if k.lower() == key.lower():
+            entry[i] = (k, value)
+            return
+    entry.append((key, value))
+
+
+def shortcuts(root):
+    for k, v in root:
+        if k.lower() == "shortcuts":
+            return v
+    raise ValueError("no shortcuts block")
+
+
+def ours(entry, exe):
+    have = get(entry, "Exe", "").strip('"')
+    return have == exe or (have.endswith("/run-app") and
+                           ("/steamify/" in have or "/cachyos-gamescope-boot/" in have))
+
+
+def load(path):
+    try:
+        with open(path, "rb") as f:
+            return parse(f.read())
+    except FileNotFoundError:
+        return [("shortcuts", [])]
+
+
+def save(path, root):
+    tmp = path + ".steamify-tmp"
+    with open(tmp, "wb") as f:
+        f.write(dump(root))
+    os.replace(tmp, path)
+
+
+def main(argv):
+    cmd, path = argv[1], argv[2]
+    root = load(path)
+    entries = shortcuts(root)
+    if cmd == "find":
+        for _, e in entries:
+            if ours(e, argv[3]):
+                print(get(e, "appid", 0))
+                return 0
+        return 1
+    if cmd == "add":
+        name, exe, icon, desktop = argv[3:7]
+        for _, e in entries:
+            if ours(e, exe):
+                put(e, "AppName", name)
+                put(e, "Exe", f'"{exe}"')
+                put(e, "StartDir", f'"{os.path.dirname(exe)}/"')
+                put(e, "icon", icon)
+                put(e, "ShortcutPath", desktop)
+                save(path, root)
+                print("updated", get(e, "appid", 0))
+                return 0
+        # Steam's own id for a shortcut: CRC32 of exe and name, top bit set.
+        appid = (zlib.crc32(f'"{exe}"{name}'.encode()) | 0x80000000) & 0xFFFFFFFF
+        entry = [("appid", appid), ("AppName", name), ("Exe", f'"{exe}"'),
+                 ("StartDir", f'"{os.path.dirname(exe)}/"'), ("icon", icon),
+                 ("ShortcutPath", desktop), ("LaunchOptions", ""), ("IsHidden", 0),
+                 ("AllowDesktopConfig", 1), ("AllowOverlay", 1), ("OpenVR", 0),
+                 ("Devkit", 0), ("DevkitGameID", ""), ("DevkitOverrideAppID", 0),
+                 ("LastPlayTime", 0), ("FlatpakAppID", ""), ("tags", [])]
+        entries.append((str(len(entries)), entry))
+        if os.path.dirname(path):
+            os.makedirs(os.path.dirname(path), exist_ok=True)
+        save(path, root)
+        print("added", appid)
+        return 0
+    if cmd == "remove":
+        keep = [e for _, e in entries if str(get(e, "appid", "")) != argv[3]]
+        if len(keep) == len(entries):
+            return 0
+        entries[:] = [(str(i), e) for i, e in enumerate(keep)]
+        save(path, root)
+        return 0
+    print(f"unknown command {cmd}", file=sys.stderr)
+    return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))

patches/steamify-cros-ec-cec.dkms.conf

@@ -0,0 +1,6 @@
+# Written by Steamify: Valve's cros_ec_cec, which knows the Steam Machine.
+PACKAGE_NAME="@NAME@"
+PACKAGE_VERSION="@VERSION@"
+BUILT_MODULE_NAME[0]="cros-ec-cec"
+DEST_MODULE_LOCATION[0]="/updates/dkms"
+AUTOINSTALL="yes"

patches/steamify-fremont-poweroff.c

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Steam Machine (Fremont): power off instead of booting up again.
+ *
+ * Since "pinctrl-amd: Don't clear S4 wake bits at probe" (Linux 7.2, also
+ * backported to 6.x, 7.0 and 7.1 updates) the S4/S5 wake bit the firmware
+ * leaves set on GPIO pin 18 (_SB.PCI0.GPP6) stays set, and the machine starts again right after powering off.
+ * Valve's kernel clears that bit at probe on Fremont (not for upstream);
+ * this does the same right before power-off, for kernels without it.
+ */
+#include <linux/acpi.h>
+#include <linux/bits.h>
+#include <linux/dmi.h>
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/reboot.h>
+
+#define FREMONT_GPP6_PIN	18
+#define WAKE_CNTRL_OFF_S4	15
+
+static void __iomem *pin_reg;
+static struct sys_off_handler *handler;
+
+static int fremont_poweroff_prepare(struct sys_off_data *data)
+{
+	u32 v = readl(pin_reg);
+
+	if (v & BIT(WAKE_CNTRL_OFF_S4))
+		writel(v & ~BIT(WAKE_CNTRL_OFF_S4), pin_reg);
+	return NOTIFY_DONE;
+}
+
+static int __init fremont_poweroff_init(void)
+{
+	struct acpi_device *adev;
+	struct device *dev;
+	struct resource *res;
+	u32 v;
+
+	if (!dmi_match(DMI_BOARD_NAME, "Fremont"))
+		return -ENODEV;
+	adev = acpi_dev_get_first_match_dev("AMDI0030", NULL, -1);
+	if (!adev)
+		return -ENODEV;
+	dev = bus_find_device_by_acpi_dev(&platform_bus_type, adev);
+	acpi_dev_put(adev);
+	if (!dev)
+		return -ENODEV;
+	res = platform_get_resource(to_platform_device(dev), IORESOURCE_MEM, 0);
+	put_device(dev);
+	if (!res || resource_size(res) < (FREMONT_GPP6_PIN + 1) * 4)
+		return -ENODEV;
+	/* pinctrl-amd owns the region; only this one register is touched. */
+	pin_reg = ioremap(res->start + FREMONT_GPP6_PIN * 4, 4);
+	if (!pin_reg)
+		return -ENOMEM;
+	v = readl(pin_reg);
+	pr_info("GPIO %d register 0x%08x, S4/S5 wake %s\n", FREMONT_GPP6_PIN, v,
+		v & BIT(WAKE_CNTRL_OFF_S4) ? "set (cleared at power-off)" : "clear");
+	handler = register_sys_off_handler(SYS_OFF_MODE_POWER_OFF_PREPARE,
+					   SYS_OFF_PRIO_DEFAULT, fremont_poweroff_prepare, NULL);
+	if (IS_ERR(handler)) {
+		iounmap(pin_reg);
+		return PTR_ERR(handler);
+	}
+	return 0;
+}
+
+static void __exit fremont_poweroff_exit(void)
+{
+	unregister_sys_off_handler(handler);
+	iounmap(pin_reg);
+}
+
+module_init(fremont_poweroff_init);
+module_exit(fremont_poweroff_exit);
+MODULE_DESCRIPTION("Steam Machine: clear GPIO 18's S4 wake bit before power-off");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("dmi:*:rnFremont:*");

patches/steamify-fremont-poweroff.dkms.conf

@@ -0,0 +1,6 @@
+# Written by Steamify: the Steam Machine powers off instead of booting up again.
+PACKAGE_NAME="@NAME@"
+PACKAGE_VERSION="@VERSION@"
+BUILT_MODULE_NAME[0]="@NAME@"
+DEST_MODULE_LOCATION[0]="/updates/dkms"
+AUTOINSTALL="yes"

patches/steamify-notifier.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+# Steamify CachyOS: update notifications (installed by the "Update
+# notifications" menu item, run by a systemd user timer and at each Plasma
+# login). Never updates anything itself: when GitHub has a newer release
+# than the last Steamify that ran here, it shows a notification (Open
+# Steamify / Skip this version) and a tray icon until you open the app,
+# skip the version or pick "Remind me later". Nothing runs in between.
+import configparser
+import json
+import os
+import subprocess
+import sys
+import threading
+import time
+import urllib.request
+
+REPO = "theupriser/steamify-cachyos"
+STATE_DIR = os.path.join(os.environ.get("XDG_STATE_HOME") or os.path.expanduser("~/.local/state"),
+                         "steamify")
+STATE = os.path.join(STATE_DIR, "notify.state")
+DATA = os.environ.get("XDG_DATA_HOME") or os.path.expanduser("~/.local/share")
+RUN_APP = os.path.join(DATA, "steamify", "bin", "run-app")
+RUN_TERMINAL = os.path.join(DATA, "steamify", "bin", "run-wizard")
+RELEASE = f"https://github.com/{REPO}/releases/latest/download"
+
+
+def version(v):
+    try:
+        return tuple(int(p) for p in v.lstrip("v").split("."))
+    except ValueError:
+        return None
+
+
+def state(key):
+    cp = configparser.ConfigParser(interpolation=None)
+    cp.read(STATE)
+    return cp.get("State", key, fallback="")
+
+
+def set_state(key, value):
+    # Same ini as lib/state.sh's state_set writes.
+    subprocess.run(["kwriteconfig6", "--file", STATE, "--group", "State", "--key", key, value], check=False)
+
+
+def latest():
+    req = urllib.request.Request(f"https://api.github.com/repos/{REPO}/releases/latest",
+                                 headers={"User-Agent": "steamify-notifier", "Accept": "application/vnd.github+json"})
+    with urllib.request.urlopen(req, timeout=30) as r:
+        return json.load(r)["tag_name"].lstrip("v")
+
+
+def pending(new):
+    # Newer than the last Steamify that ran here, and not skipped.
+    seen = version(state("seen") or "0")
+    return seen is not None and version(new) > seen and new != state("skipped")
+
+
+def desktop():
+    # Only on the Plasma desktop: gamescope doesn't show notifications or a
+    # tray, so an update found in gaming mode waits for the next desktop login.
+    return subprocess.run(["pgrep", "-u", str(os.getuid()), "-x", "plasmashell"],
+                          stdout=subprocess.DEVNULL).returncode == 0
+
+
+def main():
+    if "--delay" in sys.argv:
+        time.sleep(int(sys.argv[sys.argv.index("--delay") + 1]))
+    if not desktop():
+        return 0
+    try:
+        new = latest()
+    except Exception as e:  # offline, rate limited: try again next time
+        print(f"Couldn't check for a new Steamify: {e}", file=sys.stderr)
+        return 0
+    if version(new) is None or not pending(new):
+        return 0
+
+    from PySide6.QtCore import QObject, QTimer, Signal
+    from PySide6.QtGui import QAction, QIcon
+    from PySide6.QtWidgets import QApplication, QMenu, QSystemTrayIcon
+
+    app = QApplication(sys.argv[:1])
+    app.setApplicationName("Steamify")
+    app.setDesktopFileName("steamify-ui")
+    app.setQuitOnLastWindowClosed(False)
+    icon = QIcon.fromTheme("steamify", QIcon.fromTheme("steam"))
+
+    def open_app():
+        # The way Steamify was last used (the app or the terminal menu), the
+        # newest release either way; it records its version as seen, which
+        # ends the reminder. In its own unit: this one's processes are
+        # stopped when the check exits.
+        if state("frontend") == "terminal":
+            cmd = ["konsole", "-e", RUN_TERMINAL] if os.access(RUN_TERMINAL, os.X_OK) else \
+                  ["konsole", "-e", "bash", "-c",
+                   f"set -o pipefail; curl -fsSL --max-time 30 {RELEASE}/steamify.sh | bash; read -rp 'Press Enter to close. ' _"]
+        else:
+            cmd = [RUN_APP] if os.access(RUN_APP, os.X_OK) else \
+                  ["bash", "-c", f"set -o pipefail; curl -fsSL --max-time 30 {RELEASE}/steamify-app.sh | bash"]
+        # A scope lives as long as anything in it: the start script puts the
+        # app in the background and exits.
+        subprocess.Popen(["systemd-run", "--user", "--scope", "--collect", "--quiet", *cmd],
+                         start_new_session=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        app.quit()
+
+    def skip():
+        set_state("skipped", new)
+        app.quit()
+
+    tray = QSystemTrayIcon(icon)
+    tray.setToolTip(f"Steamify {new} is available")
+    menu = QMenu()
+    for text, fn in ((f"Open Steamify {new}", open_app), ("Skip this version", skip), ("Remind me later", app.quit)):
+        a = QAction(text, menu)
+        a.triggered.connect(fn)
+        menu.addAction(a)
+    tray.setContextMenu(menu)
+    tray.activated.connect(lambda reason: open_app() if reason == QSystemTrayIcon.ActivationReason.Trigger else None)
+    tray.show()
+
+    # The notification's buttons: notify-send waits for the click, so it
+    # runs beside the event loop. Closing it without a click keeps the icon.
+    class Relay(QObject):
+        picked = Signal(str)
+    relay = Relay()
+    relay.picked.connect(lambda a: open_app() if a == "open" else skip() if a == "skip" else None)
+
+    def notify():
+        r = subprocess.run(["notify-send", "--app-name=Steamify", "--icon=steamify",
+                            "-A", "open=Open Steamify", "-A", "skip=Skip this version",
+                            f"Steamify {new} is available",
+                            "Open Steamify to see what's new and choose what to update."],
+                           capture_output=True, text=True)
+        relay.picked.emit(r.stdout.strip())
+    threading.Thread(target=notify, daemon=True).start()
+
+    # Opened some other way (the shortcut, the terminal): the reminder is done.
+    poll = QTimer()
+    poll.timeout.connect(lambda: None if pending(new) else app.quit())
+    poll.start(60_000)
+    return app.exec()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

patches/sync-steamos-session.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+SRC="/etc/plasmalogin.conf.d/zz-steamos-autologin.conf"
+DEST="/etc/plasmalogin.conf"
+
+[[ -f "$SRC" ]] || exit 0
+SESSION=$(grep -oP '^Session=\K.*' "$SRC")
+[[ -z "$SESSION" ]] && exit 0
+
+# Only touch Session= inside [Autologin]; other sections may have their own.
+if sed -n '/^\[Autologin\]/,/^\[/p' "$DEST" | grep -q '^Session='; then
+    sed -i "/^\[Autologin\]/,/^\[/ s|^Session=.*|Session=$SESSION|" "$DEST"
+elif grep -q '^\[Autologin\]' "$DEST"; then
+    sed -i "/^\[Autologin\]/a Session=$SESSION" "$DEST"
+else
+    printf '\n[Autologin]\nSession=%s\n' "$SESSION" >> "$DEST"
+fi

services/README.md

@@ -0,0 +1,16 @@
+# Services
+
+The systemd units Steamify installs, kept out of the shell code so they can
+be read and reviewed on their own. `lib/*.sh` reads them with `service_file
+<name> [KEY=value...]`, which fills in `@KEY@` placeholders (paths the
+scripts define); the single-file build (`.github/tools/bundle.sh`) embeds
+them. Small drop-ins that only add a line or two to someone else's unit stay
+in the shell code.
+
+| File | Used by | What |
+|---|---|---|
+| `steamify-boot-desktop.service` | `lib/boot-session.sh` (Boot into: desktop) | Sets the Plasma session before the login manager starts |
+| `sync-steamos-session.path`, `.service` | `lib/login-manager.sh` (SteamOS conversion, plasma-login-manager) | The sync bridge: copies Steam's session choice into `plasmalogin.conf` |
+| `steam-desktop-autostart.service` | `lib/steam-desktop.sh` (SteamOS conversion) | Steam in the background on the Plasma desktop (user unit) |
+| `ensure-kernel-headers.service` | `lib/steam-machine.sh` (Steam Machine support) | Installs missing kernel headers at boot, so DKMS builds for every kernel |
+| `steamify-update-check.service`, `.timer` | `lib/update-notifier.sh` (Update notifications) | The daily and login check for a new release (user units) |

services/ensure-kernel-headers.service

@@ -0,0 +1,11 @@
+[Unit]
+Description=Install missing kernel headers so DKMS builds leds-valve for every kernel
+Wants=network-online.target
+After=network-online.target
+
+[Service]
+Type=oneshot
+ExecStart=@HEADERS_SCRIPT@
+
+[Install]
+WantedBy=multi-user.target

services/steam-desktop-autostart.service

@@ -0,0 +1,15 @@
+[Unit]
+Description=Steam Background Autostart for Virtual Keyboard
+After=graphical-session.target
+PartOf=graphical-session.target
+
+[Service]
+Type=simple
+# Only in the Plasma desktop session; gamescope-session starts its own Steam.
+ExecCondition=/bin/sh -c '[ "$XDG_CURRENT_DESKTOP" = KDE ]'
+ExecStart=/usr/bin/steam -silent
+Restart=on-failure
+RestartSec=5
+
+[Install]
+WantedBy=graphical-session.target

services/steamify-boot-desktop.service

@@ -0,0 +1,11 @@
+[Unit]
+Description=Steamify CachyOS: boot into the desktop instead of gaming mode
+Before=display-manager.service sddm.service plasmalogin.service
+
+[Service]
+Type=oneshot
+ExecStart=/usr/lib/steamos/steam-set-session plasma.desktop
+ExecStart=/bin/sh -c '[ -x @SESSION_SYNC@ ] && exec @SESSION_SYNC@ || true'
+
+[Install]
+WantedBy=graphical.target

services/steamify-update-check.service

@@ -0,0 +1,15 @@
+[Unit]
+Description=Steamify: check for a new release
+After=plasma-workspace.target
+# The tray icon goes with a logout.
+PartOf=graphical-session.target
+
+[Service]
+Type=simple
+# The short wait at login lets the tray come up first (in the script: an
+# ExecStartPre sleep runs into the start timeout).
+# Quoted: the path is in the home folder, which may contain a space.
+ExecStart="@NOTIFY_SCRIPT@" --delay 60
+
+[Install]
+WantedBy=plasma-workspace.target

services/steamify-update-check.timer

@@ -0,0 +1,10 @@
+[Unit]
+Description=Steamify: check for a new release daily
+
+[Timer]
+OnCalendar=daily
+RandomizedDelaySec=1h
+Persistent=true
+
+[Install]
+WantedBy=timers.target

services/sync-steamos-session.path

@@ -0,0 +1,8 @@
+[Unit]
+Description=Watch for steamos session changes
+
+[Path]
+PathModified=/etc/plasmalogin.conf.d/zz-steamos-autologin.conf
+
+[Install]
+WantedBy=multi-user.target

services/sync-steamos-session.service

@@ -0,0 +1,9 @@
+[Unit]
+Description=Sync steamos session selection into plasmalogin.conf
+# Session switches can come in bursts (switch + autologin reset); never
+# let systemd's start rate limit silently stop the bridge.
+StartLimitIntervalSec=0
+
+[Service]
+Type=oneshot
+ExecStart=/usr/local/bin/sync-steamos-session.sh

steamify.sh

@@ -15,20 +15,25 @@
 set -uo pipefail
 
 # Release version, see CHANGELOG.md.
-VERSION=1.1.2
+VERSION=2.5.1
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 
-for lib in common state packages login-manager single-user steam-desktop steam-machine cec boot-session vapor-theme steamos-extras bios desktop-shortcut wizard-shortcut menu; do
+for lib in common state packages login-manager single-user steam-desktop steam-machine fremont-poweroff vram-booster hdmi-refresh cec boot-session vapor-theme steamos-extras bios desktop-shortcut wizard-shortcut steam-game update-notifier menu backend; do
     # shellcheck source=/dev/null
     source "$SCRIPT_DIR/lib/$lib.sh"
 done
 
 require_root_helper
 
-echo -e "${c_bold}Steamify CachyOS${c_reset} v$VERSION"
-echo "Turn the SteamOS-style parts on or off. The menu shows what is on now;"
-echo "anything you turn off is put back the way it was."
+BACKEND=false
+[[ "${1:-}" == --backend ]] && BACKEND=true
+
+if [[ "$BACKEND" == false ]]; then
+    echo -e "${c_bold}Steamify CachyOS${c_reset} v$VERSION"
+    echo "Turn the SteamOS-style parts on or off. The menu shows what is on now;"
+    echo "anything you turn off is put back the way it was."
+fi
 
 if ! command -v pacman >/dev/null 2>&1; then
     err "This doesn't look like an Arch/CachyOS system (no pacman found). Aborting."
@@ -38,6 +43,8 @@ fi
 # Everything per-user (autologin user, Steam, theme, shortcut) is for the
 # user running the script.
 TARGET_USER="$(id -un)"
+migrate_layout
+notify_seen
 
 restart_needed() { [[ -n "${BIOS_NEEDS_RESTART:-}" || "$RESTART_FOR_LOGIN" == true ]]; }
 
@@ -98,6 +105,15 @@ quit_prompt() {
     return 0
 }
 
+# The graphical app (steamify-ui) drives the same components through
+# lib/backend.sh instead of the menu.
+if [[ "$BACKEND" == true ]]; then
+    RESTART_FOR_LOGIN=false
+    shift
+    backend_main "$@"
+    exit $?
+fi
+
 # Menu loop: after each run the menu comes back with the new state, until
 # the user quits; the restart question comes then, once, for everything.
 RESTART_FOR_LOGIN=false
@@ -111,6 +127,7 @@ while true; do
     plan_changes
 
     if [[ ${#TO_DISABLE[@]} -eq 0 && ${#TO_ENABLE[@]} -eq 0 ]]; then
+        feature_record_unticked
         ok "Everything is already the way you want it."
         read -rp "Press Enter to go back to the menu... " _ || break
         continue
@@ -125,7 +142,10 @@ while true; do
     for c in "${TO_ENABLE[@]}"; do
         if [[ "$c" == boot ]]; then echo "  - boot into: desktop (from the next boot)"
         elif is_action "$c"; then echo "  - run:      ${LABEL[$c]%%:*} at your own risk (checks, then asks twice more)"
-        elif [[ "${CURRENT[$c]}" == 1 ]]; then echo "  - re-apply: ${LABEL[$c]}"; else echo "  - turn on:  ${LABEL[$c]}"; fi
+        elif feature_outdated "$c"; then echo "  - update:   ${LABEL[$c]} (changed in this version)"
+        elif [[ "${CURRENT[$c]}" == 1 ]]; then echo "  - re-apply: ${LABEL[$c]}"
+        elif feature_new "$c"; then echo "  - turn on:  ${LABEL[$c]} (new in this version)"
+        else echo "  - turn on:  ${LABEL[$c]}"; fi
     done
     ask_yn "Go ahead?" y || { info "Nothing changed."; continue; }
 

ui/qml/AppState.qml

@@ -0,0 +1,282 @@
+// State and logic of the app: menu -> review -> password -> applying -> done,
+// and the BIOS update (check -> warning 1 -> warning 2 -> flash). The
+// screens only show this and call its functions.
+import QtQuick
+
+Item {
+    id: app
+    required property var backend
+    required property var gamepad
+
+    property string screen: "menu"          // menu review password applying done bios1 bios2
+    property double remoteAt: 0
+    property var want: ({})
+    property string boot: "gamescope"
+    property int sel: 0                      // row index; rows.length = the Apply button
+    property bool reapply: false
+    property var plan: []                    // [{id, action, isNew}]
+    property var steps: ({})                 // id -> "wait"|"run"|"ok"|"fail"
+    property var failed: []
+    property bool restartNeeded: false
+    // Review & apply only when something would change; "Re-apply what's on"
+    // is for when nothing did.
+    readonly property bool canApply: computePlan().length > 0
+    onCanApplyChanged: if (!canApply && sel === rows.length) sel = Math.max(0, rows.length - 1)
+    property string runError: ""
+    property bool wrongPassword: false
+    property bool typing: false              // a text field has the keys
+    property int doneCount: 0
+    property string pending: "apply"         // what the password is for: apply | bios
+    property string sessionPassword: ""      // kept between the BIOS steps only
+    property var biosInfo: ({})
+    property bool biosRun: false
+    property bool biosChecking: false        // the invisible check before the warnings
+    property int biosFocus: 0                // warning 1: 0 = Cancel, 1 = continue
+    property real holdProgress: 0            // warning 2: hold A/OK for 5 s
+    property bool holding: false
+    readonly property alias log: logModel
+
+    readonly property var status: backend.status || ({})
+    readonly property var items: status.items || []
+    readonly property var rows: items.filter(function (i) { return !i.parent || want[i.parent]; })
+    readonly property var bios: status.bios || null
+
+    signal passwordRequested()
+    signal passwordRejected()
+    signal passwordSubmitRequested()         // A/OK on the password screen
+
+    ListModel { id: logModel }
+
+    function nowOn(id) {
+        for (var i = 0; i < items.length; i++) if (items[i].id === id) return items[i].on;
+        return false;
+    }
+    function label(item) { return Texts.label(item.id, item.label); }
+    function biosHint() {
+        if (!bios) return "";
+        if (!bios.newest) return "Now " + bios.current + ", newest unknown (offline?)";
+        if (bios.current === bios.newest) return bios.current + " is up to date";
+        return "Now " + bios.current + ", newest " + bios.newest + " · at your own risk";
+    }
+    function syncFromStatus() {
+        reapply = false;
+        var w = {};
+        for (var i = 0; i < items.length; i++) w[items[i].id] = items[i].kind === "action" ? false : items[i].wanted;
+        want = w;
+        boot = nowOn("boot") ? "desktop" : "gamescope";
+        if (sel > rows.length) sel = 0;
+    }
+    Connections { target: backend; function onStatusChanged() { if (app.screen === "menu" || app.screen === "done") app.syncFromStatus(); } }
+
+    // --- Menu ---
+    function toggle(id) {
+        var cur = items.find(function (i) { return i.id === id; });
+        if (cur && cur.kind === "toggle" && cur.selectable === false) return;
+        var w = Object.assign({}, want);
+        w[id] = !w[id];
+        // The same rules as the terminal menu (toggle_component).
+        if (id === "gaming" && !w.gaming) w.single = false;
+        if (id === "single" && w.single) w.gaming = true;
+        if (id === "machine") w.poweroff = w.machine;
+        if (id === "poweroff" && w.poweroff) w.machine = true;
+        if (id === "machine" && !w.machine) w.kpin = false;
+        if (id === "kpin" && w.kpin) w.machine = true;
+        if (id === "launcher" && items.some(function (i) { return i.id === "steamgame"; })) w.steamgame = w.launcher;
+        if (id === "steamgame" && w.steamgame) w.launcher = true;
+        want = w;
+    }
+    function computePlan() {
+        var p = [];
+        for (var i = 0; i < items.length; i++) {
+            var it = items[i];
+            if (it.kind !== "toggle") continue;
+            if (it.parent && !want[it.parent]) { if (it.on) p.push({ id: it.id, action: "off" }); continue; }
+            if (want[it.id] && !it.on) p.push({ id: it.id, action: "on", isNew: !!it["new"] });
+            else if (!want[it.id] && it.on) p.push({ id: it.id, action: "off" });
+            else if (want[it.id] && (reapply || it.update)) p.push({ id: it.id, action: reapply ? "again" : "update" });
+        }
+        var bootNow = nowOn("boot") ? "desktop" : "gamescope";
+        if (want.gaming && boot !== bootNow) p.push({ id: "boot", action: boot === "desktop" ? "desktop" : "gaming" });
+        return p;
+    }
+    function goReview(again) {
+        if (!again && !canApply) return;
+        reapply = again; plan = computePlan(); screen = "review";
+    }
+    function wantedIds() {
+        var ids = [];
+        for (var i = 0; i < items.length; i++)
+            if (items[i].kind === "toggle" && want[items[i].id] && (!items[i].parent || want[items[i].parent])) ids.push(items[i].id);
+        return ids;
+    }
+
+    // --- Password and apply ---
+    function resetRun() { steps = {}; failed = []; restartNeeded = false; runError = ""; doneCount = 0; logModel.clear(); }
+    function startApply(password) {
+        resetRun();
+        var s = {};
+        for (var i = 0; i < plan.length; i++) s[plan[i].id] = "wait";
+        steps = s;
+        screen = "applying";
+        backend.apply(wantedIds(), want.gaming ? boot : "", reapply, password || "");
+    }
+    function askPassword(forWhat) {
+        pending = forWhat;
+        if (!backend.needsPassword()) return false;
+        wrongPassword = false; screen = "password"; passwordRequested();
+        return true;
+    }
+    function onApplyPressed() {
+        if (plan.length === 0) return;
+        if (!askPassword("apply")) startApply("");
+    }
+    function submitPassword(p) {
+        if (!backend.checkPassword(p)) { wrongPassword = true; passwordRejected(); return; }
+        if (pending === "bios") { sessionPassword = p; biosCheck(); }
+        else startApply(p);
+    }
+    function passwordBack() { screen = pending === "bios" ? "menu" : "review"; }
+
+    // --- BIOS ---
+    function startBios() {
+        if (!bios || !bios.selectable) return;
+        biosInfo = {}; sessionPassword = "";
+        if (!askPassword("bios")) biosCheck();
+    }
+    function biosCheck() {
+        // Invisible: stay on the menu (the BIOS row says "Checking…"),
+        // then the first warning.
+        failed = []; runError = ""; logModel.clear();
+        plan = [{ id: "bios", action: "check" }];
+        biosRun = true; biosChecking = true; screen = "menu";
+        backend.biosPrepare(sessionPassword);
+    }
+    function biosCancel() { sessionPassword = ""; holdProgress = 0; holding = false; biosRun = false; syncFromStatus(); screen = "menu"; }
+    function biosContinue() { holdProgress = 0; screen = "bios2"; }
+    function biosFlash() {
+        holdProgress = 0; holding = false;
+        resetRun();
+        plan = [{ id: "bios", action: "flash" }];
+        steps = { bios: "wait" };
+        biosRun = true; screen = "applying";
+        backend.biosFlash(sessionPassword);
+    }
+    Timer {
+        interval: 50; repeat: true; running: app.screen === "bios2" && app.holding
+        onTriggered: { app.holdProgress = Math.min(1, app.holdProgress + 0.01); if (app.holdProgress >= 1) app.biosFlash(); }
+    }
+
+    function backToMenu() { biosRun = false; syncFromStatus(); screen = "menu"; }
+
+    // --- Backend events ---
+    function errorText(e) {
+        return e === "wrong-password" ? "The password didn't work." : (e === "start" ? "Steamify couldn't start the changes." : (e ? "sudo isn't available." : ""));
+    }
+    Connections {
+        target: app.backend
+        function onEvent(ev) {
+            var s = Object.assign({}, app.steps);
+            if (ev.event === "start") { s[ev.id] = "run"; app.steps = s; }
+            else if (ev.event === "done") { s[ev.id] = ev.ok ? "ok" : "fail"; app.steps = s; app.doneCount++; }
+            else if (ev.event === "log") { logModel.append({ line: ev.line }); if (logModel.count > 400) logModel.remove(0); }
+            else if (ev.event === "bios-ready") { app.biosChecking = false; app.biosInfo = ev; app.biosFocus = 0; app.holdProgress = 0; app.screen = "bios1"; }
+            else if (ev.event === "finished" && app.biosChecking) {
+                // The check found nothing to do or a problem: say so.
+                app.biosChecking = false; app.sessionPassword = "";
+                app.failed = ev.failed || []; app.restartNeeded = false;
+                app.runError = ev.nothing && !ev.error ? "The BIOS is already the newest version." : app.errorText(ev.error);
+                app.screen = "done";
+            }
+            else if (ev.event === "finished") {
+                // A successful BIOS check ends with bios-ready instead, keeping
+                // the password for the flash.
+                app.sessionPassword = "";
+                app.failed = ev.failed || []; app.restartNeeded = !!ev.restart;
+                app.runError = app.errorText(ev.error);
+                app.screen = "done";
+            }
+        }
+        function onRemotePressed() { app.remoteAt = Date.now(); Input.type = "remote"; }
+    }
+
+    // --- Input: one set of actions for controller, keyboard and remote ---
+    function act(a) {
+        if (screen === "menu") {
+            if (biosChecking) return;
+            if (a === "up") sel = Math.max(0, sel - 1);
+            // The greyed-out Apply button can't be selected.
+            else if (a === "down") sel = Math.min(canApply ? rows.length : rows.length - 1, sel + 1);
+            else if (a === "accept") {
+                if (sel === rows.length) { goReview(false); return; }
+                var r = rows[sel];
+                if (r.kind === "action" && r.id === "bios") startBios();
+                else if (r.kind === "choice") boot = boot === "gamescope" ? "desktop" : "gamescope";
+                else if (r.kind === "toggle") toggle(r.id);
+            }
+            else if ((a === "left" || a === "right") && sel < rows.length && rows[sel].kind === "choice")
+                boot = a === "left" ? "gamescope" : "desktop";
+            else if (a === "apply") goReview(false);
+            else if (a === "reapply") goReview(true);
+            // B/Esc/Back don't quit: Steam's desktop layout sends Esc for a
+            // Steam Controller's B, which should only ever go back.
+            else if (a === "quit") Qt.quit();
+        } else if (screen === "review") {
+            if (a === "accept" || a === "apply") onApplyPressed();
+            else if (a === "back") { reapply = false; screen = "menu"; }
+        } else if (screen === "password") {
+            if (a === "accept" || a === "apply") passwordSubmitRequested();
+            else if (a === "back") passwordBack();
+        } else if (screen === "bios1") {
+            if (a === "left") biosFocus = 0;
+            else if (a === "right") biosFocus = 1;
+            else if (a === "accept") { if (biosFocus === 1) biosContinue(); else biosCancel(); }
+            else if (a === "back") biosCancel();
+        } else if (screen === "bios2") {
+            if (a === "back") biosCancel();
+            else if (a === "hold") holding = true;
+            else if (a === "release") { holding = false; if (holdProgress < 1) holdProgress = 0; }
+        } else if (screen === "done") {
+            if (a === "accept" && restartNeeded) backend.restart();
+            else if (a === "back" || a === "accept") backToMenu();
+        }
+    }
+    Connections {
+        target: app.gamepad
+        function onButton(b) {
+            if (b === "a_up") { if (app.screen === "bios2") app.act("release"); return; }
+            if (b.slice(-3) === "_up") return;
+            Input.type = "controller";
+            if (b === "a" && app.screen === "bios2") { app.act("hold"); return; }
+            var map = { a: "accept", b: "back", x: "apply", y: "reapply", start: "apply", up: "up", down: "down", left: "left", right: "right" };
+            if (map[b]) app.act(map[b]);
+        }
+    }
+    function keyPressed(e) {
+        // A text field handles its own keys, except Escape and Enter.
+        if (typing && e.key !== Qt.Key_Escape && e.key !== Qt.Key_Return && e.key !== Qt.Key_Enter) return;
+        var fromRemote = Date.now() - remoteAt < 400;
+        if (screen === "bios2" && Input.type !== "keyboard" && (e.key === Qt.Key_Return || e.key === Qt.Key_Enter)) {
+            if (!e.isAutoRepeat) act("hold"); e.accepted = true; return;
+        }
+        if (!fromRemote) Input.type = Input.fromSteam ? "steam" : "keyboard";
+        var k = e.key;
+        if (k === Qt.Key_Up) act("up");
+        else if (k === Qt.Key_Down) act("down");
+        else if (k === Qt.Key_Left) act("left");
+        else if (k === Qt.Key_Right) act("right");
+        else if (k === Qt.Key_Space) act("accept");
+        // Enter selects, like A on a controller: Steam's desktop layout sends
+        // Enter for a Steam Controller's A (and Space for Y). Ctrl+Enter
+        // goes straight to Review & apply.
+        else if ((k === Qt.Key_Return || k === Qt.Key_Enter) && (e.modifiers & Qt.ControlModifier)) act("apply");
+        else if (k === Qt.Key_Return || k === Qt.Key_Enter) act("accept");
+        else if (k === Qt.Key_Escape || k === Qt.Key_Back || k === Qt.Key_Backspace) { if (!e.isAutoRepeat) act("back"); }
+        else if (k === Qt.Key_R) act("reapply");
+        else if (k === Qt.Key_Q && (e.modifiers & Qt.ControlModifier)) act("quit");
+        else return;
+        e.accepted = true;
+    }
+    function keyReleased(e) {
+        if (screen === "bios2" && !e.isAutoRepeat && (e.key === Qt.Key_Return || e.key === Qt.Key_Enter)) act("release");
+    }
+}

ui/qml/ApplyingScreen.qml

@@ -0,0 +1,60 @@
+// Progress: every step of the plan on the left, the log on the right.
+import QtQuick
+import QtQuick.Controls.Basic
+
+Item {
+    required property AppState app
+    readonly property bool checking: app.biosRun && app.plan.length > 0 && app.plan[0].action === "check"
+    Column {
+        x: 40; y: 32; width: 560; spacing: 18
+        Text { text: app.biosRun ? (checking ? "Checking the BIOS update" : "Installing the BIOS update") : "Applying your changes"
+               color: Theme.text; font.family: Theme.display; font.pixelSize: 34; font.weight: Font.DemiBold }
+        Rectangle { width: 560; height: 10; radius: 5; color: Theme.line
+            Rectangle { height: 10; radius: 5; color: Theme.accent; width: app.plan.length ? parent.width * Math.min(1, (app.doneCount + 0.3) / app.plan.length) : 0
+                        Behavior on width { NumberAnimation { duration: 300 } } } }
+        Row { width: 560
+            Text { text: "Step " + Math.min(app.plan.length, app.doneCount + 1) + " of " + app.plan.length; color: Theme.mute; font.family: Theme.body; font.pixelSize: 14; width: 280 }
+            Text { text: "Don't turn off the PC"; color: Theme.mute; font.family: Theme.body; font.pixelSize: 14; width: 280; horizontalAlignment: Text.AlignRight } }
+        ListView {
+            width: 560; clip: true; spacing: 8
+            height: parent.parent.height - 32 - 156 - 32
+            model: app.plan
+            ScrollBar.vertical: ScrollBar { policy: ScrollBar.AsNeeded }
+            // Follow the progress: the running step stays in view.
+            readonly property int running: app.plan.findIndex(function (p) { return app.steps[p.id] === "run"; })
+            onRunningChanged: if (running >= 0) positionViewAtIndex(running, ListView.Contain)
+            delegate: Rectangle {
+                id: step
+                required property var modelData
+                readonly property string st: app.steps[modelData.id] || "wait"
+                width: 560; height: 54; radius: 12; color: st === "run" ? Theme.cardSel : Theme.card
+                border.width: st === "run" ? 2 : 0; border.color: Theme.accent
+                Row { anchors.fill: parent; anchors.leftMargin: 18; anchors.rightMargin: 18; spacing: 14
+                    Rectangle { width: 22; height: 22; radius: 11; anchors.verticalCenter: parent.verticalCenter
+                        color: step.st === "ok" ? Theme.goodBg : (step.st === "fail" ? Theme.badBg : "transparent")
+                        border.width: step.st === "wait" || step.st === "run" ? 2 : 0; border.color: step.st === "run" ? Theme.accent : "#343f50"
+                        Text { anchors.centerIn: parent; text: step.st === "ok" ? "✓" : (step.st === "fail" ? "!" : ""); color: step.st === "ok" ? Theme.good : Theme.bad
+                               font.pixelSize: 13; font.weight: Font.Bold }
+                        RotationAnimator on rotation { running: step.st === "run"; from: 0; to: 360; duration: 1000; loops: Animation.Infinite } }
+                    Row { width: 380; anchors.verticalCenter: parent.verticalCenter; spacing: 10
+                        Text { text: (Texts.actions[step.modelData.action] || [])[3] + Texts.label(step.modelData.id)
+                               color: step.st === "wait" ? Theme.faint : Theme.textHi; font.family: Theme.body; font.pixelSize: 16; font.weight: Font.DemiBold
+                               anchors.verticalCenter: parent.verticalCenter; elide: Text.ElideRight
+                               width: Math.min(implicitWidth, parent.width - (badge.visible ? badge.width + parent.spacing : 0)) }
+                        Badge { id: badge; update: step.modelData.action === "update"; isNew: !!step.modelData.isNew; anchors.verticalCenter: parent.verticalCenter } }
+                    Text { text: ({ wait: "Waiting", run: "Working…", ok: "Done", fail: "Problem" })[step.st]
+                           color: step.st === "ok" ? Theme.good : (step.st === "fail" ? Theme.bad : Theme.label); font.family: Theme.body; font.pixelSize: 13
+                           anchors.verticalCenter: parent.verticalCenter }
+                }
+            }
+        }
+    }
+    Column {
+        x: 632; y: 32; width: parent.width - 672; height: parent.height - 64; spacing: 10
+        Text { text: "DETAILS"; color: Theme.faint; font.family: Theme.body; font.pixelSize: 12; font.weight: Font.DemiBold; font.letterSpacing: 0.8 }
+        Rectangle { width: parent.width; height: parent.height - 30; radius: 16; color: "#0b0e13"; border.width: 1; border.color: "#1d2531"
+            ListView { id: logView; anchors.fill: parent; anchors.margins: 18; clip: true; model: app.log
+                onCountChanged: positionViewAtEnd()
+                delegate: Text { required property string line; width: logView.width; text: line; color: "#aab5c4"; font.family: Theme.mono; font.pixelSize: 13; wrapMode: Text.WrapAnywhere } } }
+    }
+}

ui/qml/Badge.qml

@@ -0,0 +1,13 @@
+// "Update" (a newer version of it will be applied) or "New" (a default
+// option added since the last run), after an item's name.
+import QtQuick
+
+Chip {
+    property bool update: false
+    property bool isNew: false
+    visible: update || isNew
+    height: 20
+    text: update ? "Update" : "New"
+    fg: update ? Theme.warn : Theme.good
+    bgc: update ? Theme.warnBg : Theme.goodBg
+}

ui/qml/Bar.qml

@@ -0,0 +1,7 @@
+// The bar at the bottom of a screen, for its buttons.
+import QtQuick
+
+Rectangle {
+    anchors.bottom: parent.bottom; width: parent.width; height: 64; color: Theme.bar
+    Rectangle { width: parent.width; height: 1; color: Theme.line }
+}

ui/qml/BiosConfirmScreen.qml

@@ -0,0 +1,36 @@
+// BIOS update, warning 2 (last chance): type UPDATE on a keyboard, or hold
+// A/OK for 5 seconds on a controller or remote.
+import QtQuick
+import QtQuick.Controls.Basic
+
+Item {
+    id: screen
+    required property AppState app
+    onVisibleChanged: if (visible) { typed.text = ""; if (Input.type === "keyboard") typed.forceActiveFocus(); }
+    Binding { target: screen.app; property: "typing"; value: typed.activeFocus; when: screen.visible }
+
+    Rectangle {
+        anchors.centerIn: parent; width: 760; height: col.implicitHeight + 64; radius: 20; color: Theme.dangerBg; border.width: 2; border.color: Theme.dangerLine
+        Column { id: col; anchors.fill: parent; anchors.margins: 32; spacing: 18
+            Text { text: "Last chance: this flashes BIOS " + (app.biosInfo.newest || ""); color: "#ffd9d3"; font.family: Theme.display; font.pixelSize: 32; font.weight: Font.DemiBold }
+            Text { width: parent.width; wrapMode: Text.WordWrap; color: Theme.soft; font.family: Theme.body; font.pixelSize: 16; lineHeight: 1.3
+                   text: "After this, keep the power on until the machine has fully started again. Don't touch it, even if the screen is black." }
+            Column { visible: Input.type === "keyboard"; width: parent.width; spacing: 8
+                Text { text: "Type UPDATE (in capitals) and press Enter to flash the BIOS:"; color: Theme.text; font.family: Theme.body; font.pixelSize: 15; font.weight: Font.DemiBold }
+                TextField { id: typed; width: 320; height: 50; color: Theme.textHi; font.family: Theme.mono; font.pixelSize: 20; leftPadding: 14
+                    placeholderText: "UPDATE"; placeholderTextColor: "#6b5a5a"
+                    background: Rectangle { radius: 10; color: Theme.bg; border.width: 2; border.color: typed.text === "UPDATE" ? Theme.bad : "#5a3a3a" }
+                    Keys.onReturnPressed: if (text === "UPDATE") app.biosFlash()
+                    Keys.onEnterPressed: if (text === "UPDATE") app.biosFlash()
+                    Keys.onEscapePressed: app.biosCancel() } }
+            Column { visible: Input.type !== "keyboard"; width: parent.width; spacing: 10
+                Text { text: "Hold " + Input.g.ok + " for 5 seconds to flash the BIOS. Let go to stop."; color: Theme.text; font.family: Theme.body; font.pixelSize: 15; font.weight: Font.DemiBold }
+                Rectangle { width: parent.width; height: 14; radius: 7; color: "#3a2224"
+                    Rectangle { height: 14; radius: 7; color: Theme.bad; width: parent.width * app.holdProgress } } }
+            Row { spacing: 12
+                Btn { k: Input.g.back; text: "Cancel"; onClicked: app.biosCancel() }
+                Text { visible: app.bios && app.bios.dryRun; text: "Dry run: nothing will be flashed."; color: Theme.warn; font.family: Theme.body; font.pixelSize: 14
+                       anchors.verticalCenter: parent.verticalCenter } }
+        }
+    }
+}

ui/qml/BiosWarningScreen.qml

@@ -0,0 +1,37 @@
+// BIOS update, warning 1: the risks and what was checked; Cancel is
+// selected first.
+import QtQuick
+
+Item {
+    required property AppState app
+    Rectangle {
+        x: 40; y: 28; width: parent.width - 80; height: parent.height - 28 - 64 - 24; radius: 16; color: Theme.dangerBg; border.width: 2; border.color: Theme.dangerLine
+        Row { anchors.fill: parent; anchors.margins: 32; spacing: 40
+            Column { width: 640; spacing: 16
+                Row { spacing: 12
+                    Rectangle { width: 44; height: 44; radius: 12; color: "#3a1c1f"
+                        Text { anchors.centerIn: parent; text: "!"; color: Theme.bad; font.pixelSize: 26; font.weight: Font.Bold } }
+                    Text { text: "BIOS update – entirely at your own risk"; color: "#ffd9d3"; font.family: Theme.display; font.pixelSize: 30; font.weight: Font.DemiBold
+                           anchors.verticalCenter: parent.verticalCenter } }
+                RiskList { width: 640 }
+            }
+            Rectangle { width: 440; height: 250; radius: 14; color: Theme.card
+                Column { anchors.fill: parent; anchors.margins: 22; spacing: 12
+                    Repeater { model: [["Current BIOS", app.biosInfo.current || ""], ["New BIOS", app.biosInfo.newest || ""], ["Checksum", "OK (Valve's package)"],
+                                       ["Compatible", app.biosInfo.compatible === "yes" ? "Yes (checked by fwupd)" : "Not checked (dry run)"]]
+                        Row { required property var modelData; width: 396
+                            Text { text: parent.modelData[0]; color: Theme.faint; font.family: Theme.body; font.pixelSize: 15; width: 150 }
+                            Text { text: parent.modelData[1]; color: parent.modelData[1].indexOf("Not") === 0 ? Theme.warn : Theme.text; font.family: Theme.mono; font.pixelSize: 15
+                                   width: 246; horizontalAlignment: Text.AlignRight; elide: Text.ElideLeft } } }
+                } }
+        }
+    }
+    Bar {
+        Text { anchors.left: parent.left; anchors.leftMargin: 40; anchors.verticalCenter: parent.verticalCenter; text: "Do you understand the risks and want to continue?"
+               color: Theme.soft; font.family: Theme.body; font.pixelSize: 15 }
+        Row { anchors.right: parent.right; anchors.rightMargin: 40; anchors.verticalCenter: parent.verticalCenter; spacing: 12
+            Btn { k: app.biosFocus === 0 ? Input.g.ok : "◀"; text: "Cancel"; focusRing: app.biosFocus === 0; onClicked: app.biosCancel() }
+            Btn { k: app.biosFocus === 1 ? Input.g.ok : "▶"; text: "I understand, continue"; focusRing: app.biosFocus === 1; color: Theme.danger
+                  onClicked: app.biosContinue() } }
+    }
+}

ui/qml/Btn.qml

@@ -0,0 +1,22 @@
+// A button with the input's button name in front.
+import QtQuick
+
+Rectangle {
+    id: btn
+    property string k
+    property string text
+    property bool primary: false
+    property bool focusRing: false
+    signal clicked
+    height: 48; radius: 12; width: row.implicitWidth + 36
+    color: primary ? Theme.accent : Theme.button
+    border.width: focusRing && enabled ? 2 : 0; border.color: Theme.textHi
+    // Greyed out while there's nothing to do.
+    opacity: enabled ? 1 : 0.4
+    Row { id: row; anchors.centerIn: parent; spacing: 10
+        Glyph { k: btn.k; visible: btn.k !== ""; dark: btn.primary; anchors.verticalCenter: parent.verticalCenter }
+        Text { text: btn.text; color: btn.primary ? Theme.ink : Theme.text; font.family: Theme.body; font.pixelSize: 15; font.weight: Font.DemiBold
+               anchors.verticalCenter: parent.verticalCenter }
+    }
+    MouseArea { anchors.fill: parent; enabled: btn.enabled; cursorShape: Qt.PointingHandCursor; onClicked: btn.clicked() }
+}

ui/qml/Chip.qml

@@ -0,0 +1,12 @@
+// A small label in capitals.
+import QtQuick
+
+Rectangle {
+    id: chip
+    property string text
+    property color fg: Theme.good
+    property color bgc: Theme.goodBg
+    height: 24; radius: 6; width: ct.implicitWidth + 16; color: bgc
+    Text { id: ct; anchors.centerIn: parent; text: chip.text.toUpperCase(); color: chip.fg
+           font.family: Theme.body; font.pixelSize: 12; font.weight: Font.DemiBold; font.letterSpacing: 0.6 }
+}

ui/qml/DetailPanel.qml

@@ -0,0 +1,45 @@
+// Right of the menu: what the selected item does, or a nudge to review
+// when the Apply button is selected.
+import QtQuick
+import QtQuick.Controls.Basic
+
+Rectangle {
+    id: detail
+    required property AppState app
+    readonly property var it: app.sel < app.rows.length ? app.rows[app.sel] : null
+    readonly property var tx: it ? Texts.of(it) : ({})
+    radius: 16; color: Theme.card
+    // Long texts scroll instead of running out of the card; each item
+    // starts at the top.
+    onItChanged: flick.contentY = 0
+
+    Flickable {
+        id: flick
+        anchors.fill: parent; anchors.margins: 24; anchors.rightMargin: 12
+        visible: detail.it !== null; clip: true
+        contentHeight: col.implicitHeight; boundsBehavior: Flickable.StopAtBounds
+        ScrollBar.vertical: ScrollBar { policy: ScrollBar.AsNeeded }
+        Column {
+            id: col; width: flick.width - 12; spacing: 14
+            Row { spacing: 10
+                Chip { readonly property var it: detail.it
+                       text: !it ? "" : it.kind === "choice" ? (app.boot === "desktop" ? "Desktop" : "Gaming") : it.kind === "action" ? "Opt-in" : (it.on ? "On" : "Off")
+                       fg: it && it.on ? Theme.good : Theme.label; bgc: it && it.on ? Theme.goodBg : Theme.line }
+                Chip { visible: !!detail.tx.experimental; text: "Experimental"; fg: Theme.warn; bgc: Theme.warnBg }
+            }
+            Text { text: detail.it ? app.label(detail.it) : ""; color: Theme.text; font.family: Theme.display; font.pixelSize: 26; font.weight: Font.DemiBold
+                   wrapMode: Text.WordWrap; width: parent.width }
+            Text { text: detail.tx.body || ""; color: Theme.soft; font.family: Theme.body; font.pixelSize: 15; lineHeight: 1.4; wrapMode: Text.WordWrap; width: parent.width }
+            Text { text: "WHAT IT CHANGES"; color: Theme.faint; font.family: Theme.body; font.pixelSize: 12; font.weight: Font.DemiBold; font.letterSpacing: 0.8; topPadding: 4 }
+            Repeater { model: detail.tx.changes || []
+                Text { required property string modelData; text: "•  " + modelData; color: Theme.soft; font.family: Theme.body; font.pixelSize: 14
+                       wrapMode: Text.WordWrap; width: col.width } }
+        }
+    }
+    Column {
+        anchors.centerIn: parent; spacing: 8; visible: detail.it === null
+        Text { text: app.computePlan().length === 0 ? "Everything is the way you want it" : "Review what will change"; color: Theme.text
+               font.family: Theme.display; font.pixelSize: 24; anchors.horizontalCenter: parent.horizontalCenter }
+        Text { text: "then apply it"; color: Theme.mute; font.family: Theme.body; font.pixelSize: 15; anchors.horizontalCenter: parent.horizontalCenter }
+    }
+}

ui/qml/DoneScreen.qml

@@ -0,0 +1,38 @@
+// The result of a run: all done, a problem, or nothing changed. With a
+// problem, the run's output is shown below it (a BIOS check has no progress
+// screen, so this is the only place to read why it stopped).
+import QtQuick
+import QtQuick.Controls.Basic
+
+Item {
+    required property AppState app
+    readonly property bool problem: app.failed.length > 0 || app.runError !== ""
+    readonly property string message: {
+        if (app.runError) return app.runError;
+        if (!app.biosRun) return app.plan.length + (app.plan.length === 1 ? " change" : " changes") + " applied." + (app.restartNeeded ? " Some take effect after a restart." : "");
+        if (app.failed.length) return "The BIOS was not changed.";
+        return (app.bios && app.bios.dryRun ? "Dry run: nothing was flashed. " : "BIOS " + (app.biosInfo.newest || "") + " is staged and is written during the restart. ")
+             + "Keep the power on and don't touch the machine until it has fully started again, even if the screen stays black.";
+    }
+    Column {
+        anchors.centerIn: parent; width: 760; spacing: 20
+        Rectangle { width: 72; height: 72; radius: 36; anchors.horizontalCenter: parent.horizontalCenter; color: problem ? Theme.warnBg : Theme.goodBg
+            Text { anchors.centerIn: parent; text: problem ? "!" : "✓"; color: problem ? Theme.warn : Theme.good; font.pixelSize: 36; font.weight: Font.Bold } }
+        Text { text: app.runError ? "Nothing changed" : (app.biosRun && app.failed.length ? "The BIOS update stopped" : (app.failed.length ? "Done, with a problem" : "All done"))
+               color: Theme.text; font.family: Theme.display; font.pixelSize: 40; font.weight: Font.DemiBold; anchors.horizontalCenter: parent.horizontalCenter }
+        Text { width: parent.width; horizontalAlignment: Text.AlignHCenter; wrapMode: Text.WordWrap; color: Theme.soft; font.family: Theme.body; font.pixelSize: 17; text: message }
+        Rectangle { visible: app.failed.length > 0; anchors.horizontalCenter: parent.horizontalCenter; width: ft.implicitWidth + 32; height: 44; radius: 12; color: Theme.warnBg
+            Text { id: ft; anchors.centerIn: parent; color: "#f2c27a"; font.family: Theme.body; font.pixelSize: 14
+                   text: "Had a problem: " + app.failed.map(function (id) { return Texts.label(id); }).join(", ") + (app.log.count ? ". Details below." : ".") } }
+        Rectangle { visible: app.failed.length > 0 && app.log.count > 0; width: parent.width; height: 190; radius: 14; color: Theme.card
+            ListView { id: details; anchors.fill: parent; anchors.margins: 16; clip: true; model: app.log
+                ScrollBar.vertical: ScrollBar { policy: ScrollBar.AsNeeded }
+                // The end is where it stopped.
+                onCountChanged: positionViewAtEnd()
+                onVisibleChanged: if (visible) positionViewAtEnd()
+                delegate: Text { required property string line; width: details.width - 12; text: line; color: "#aab5c4"; font.family: Theme.mono; font.pixelSize: 13; wrapMode: Text.WrapAnywhere } } }
+        Row { anchors.horizontalCenter: parent.horizontalCenter; spacing: 14; topPadding: 8
+            Btn { k: Input.g.back; text: "Back to the menu"; height: 52; onClicked: app.act("back") }
+            Btn { visible: app.restartNeeded; k: Input.g.ok; text: "Restart now"; primary: true; height: 52; onClicked: app.backend.restart() } }
+    }
+}

ui/qml/Glyph.qml

@@ -0,0 +1,13 @@
+// A button name (A, Enter, OK...), round for a controller's face buttons.
+import QtQuick
+
+Rectangle {
+    id: glyph
+    property string k
+    property bool dark: false
+    height: 26; width: Math.max(26, gt.implicitWidth + 14)
+    radius: (Input.type === "controller" || Input.type === "steam") && k.length === 1 ? 13 : 7
+    color: dark ? Theme.ink : Theme.key
+    Text { id: gt; anchors.centerIn: parent; text: glyph.k; color: glyph.dark ? Theme.accent : Theme.textHi
+           font.family: Theme.body; font.pixelSize: 12; font.weight: Font.DemiBold }
+}

ui/qml/Header.qml

@@ -0,0 +1,25 @@
+// Logo, the screen's name (the version on the menu) and the machine.
+import QtQuick
+
+Rectangle {
+    required property AppState app
+    required property string iconUrl
+    readonly property var titles: ({ review: "Review", password: "Password", applying: app.biosRun ? "BIOS update" : "Applying",
+                                     done: "Done", bios1: "BIOS update", bios2: "BIOS update" })
+    width: parent.width; height: 72; color: Theme.bar
+    Rectangle { anchors.bottom: parent.bottom; width: parent.width; height: 1; color: Theme.line }
+    Row {
+        anchors.left: parent.left; anchors.leftMargin: 40; anchors.verticalCenter: parent.verticalCenter; spacing: 14
+        Image { source: iconUrl; width: 40; height: 40; sourceSize: Qt.size(80, 80); anchors.verticalCenter: parent.verticalCenter }
+        Text { text: "Steamify"; color: Theme.text; font.family: Theme.display; font.pixelSize: 28; font.weight: Font.Bold; anchors.verticalCenter: parent.verticalCenter }
+        Text { readonly property bool menu: app.screen === "menu"
+               text: menu ? "v" + (app.status.version || "") : "/ " + titles[app.screen]
+               color: Theme.faint; font.family: menu ? Theme.mono : Theme.body; font.pixelSize: menu ? 13 : 15; anchors.verticalCenter: parent.verticalCenter }
+    }
+    Rectangle {
+        visible: app.status.steamMachine === true
+        anchors.right: parent.right; anchors.rightMargin: 40; anchors.verticalCenter: parent.verticalCenter
+        height: 34; radius: 17; color: "#1b2330"; width: mt.implicitWidth + 28
+        Text { id: mt; anchors.centerIn: parent; text: "Steam Machine · CachyOS"; color: Theme.label; font.family: Theme.body; font.pixelSize: 14 }
+    }
+}

ui/qml/Input.qml

@@ -0,0 +1,19 @@
+// The input in use (controller, keyboard or remote) and the button names
+// shown for it.
+pragma Singleton
+import QtQuick
+
+QtObject {
+    property string type: "keyboard"
+    // Started from Steam: keys come from a Steam Controller through Steam's
+    // desktop layout (A = Enter, B = Esc, Y = Space, X = Steam's keyboard),
+    // shown as "steam" with the controller's buttons.
+    property bool fromSteam: false
+    readonly property var glyphs: ({
+        controller: { toggle: "A", choose: "◀ ▶", reapply: "Y", quit: "", apply: "X", ok: "A", back: "B" },
+        keyboard: { toggle: "Enter", choose: "← →", reapply: "R", quit: "Ctrl+Q", apply: "Ctrl+Enter", ok: "Enter", back: "Esc" },
+        steam: { toggle: "A", choose: "◀ ▶", reapply: "", quit: "", apply: "↓ A", ok: "A", back: "B" },
+        remote: { toggle: "OK", choose: "◀ ▶", reapply: "Red", quit: "", apply: "↓ Apply", ok: "OK", back: "Back" }
+    })
+    readonly property var g: glyphs[type]
+}

ui/qml/Main.qml

@@ -0,0 +1,58 @@
+// Steamify v2: the window. The state and logic are in AppState.qml, each
+// screen in its own file (menu -> review -> password -> applying -> done,
+// and the BIOS warnings). Designed at 1280x720 and scaled to the window, so
+// it fits a TV too.
+import QtQuick
+import QtQuick.Window
+import QtQuick.Controls.Basic
+
+ApplicationWindow {
+    id: win
+    required property var backend
+    required property var gamepad
+    required property bool fullscreen
+    required property string iconUrl
+    required property bool fromSteam
+    Component.onCompleted: Input.fromSteam = fromSteam
+
+    width: 1280; height: 720
+    minimumWidth: 960; minimumHeight: 540
+    visibility: fullscreen ? Window.FullScreen : Window.Windowed
+    title: "Steamify"
+    color: Theme.bg
+
+    AppState {
+        id: steamify
+        backend: win.backend
+        gamepad: win.gamepad
+        // Keys go back to the screen when a text field's screen closes.
+        onScreenChanged: if (screen !== "password" && screen !== "bios2") stage.forceActiveFocus()
+    }
+
+    // The 1280x720 stage, scaled to the window: stretched to the window's
+    // own shape, so the bars reach the edges and the content fills it.
+    Item {
+        id: stage
+        readonly property real k: Math.min(win.width / 1280, win.height / 720)
+        width: win.width / k; height: win.height / k
+        transformOrigin: Item.TopLeft
+        scale: k
+        focus: true
+        Keys.onPressed: function (e) { steamify.keyPressed(e); }
+        Keys.onReleased: function (e) { steamify.keyReleased(e); }
+
+        Header { id: header; app: steamify; iconUrl: win.iconUrl }
+
+        Item {
+            id: content
+            anchors.top: header.bottom; anchors.bottom: parent.bottom; width: parent.width
+            MenuScreen { anchors.fill: parent; app: steamify; visible: steamify.screen === "menu" }
+            ReviewScreen { anchors.fill: parent; app: steamify; visible: steamify.screen === "review" }
+            PasswordScreen { anchors.fill: parent; app: steamify; visible: steamify.screen === "password" }
+            ApplyingScreen { anchors.fill: parent; app: steamify; visible: steamify.screen === "applying" }
+            BiosWarningScreen { anchors.fill: parent; app: steamify; visible: steamify.screen === "bios1" }
+            BiosConfirmScreen { anchors.fill: parent; app: steamify; visible: steamify.screen === "bios2" }
+            DoneScreen { anchors.fill: parent; app: steamify; visible: steamify.screen === "done" }
+        }
+    }
+}

ui/qml/MenuRow.qml

@@ -0,0 +1,80 @@
+// One menu item: name, badge and hint on the left; its control (switch,
+// Gaming/Desktop choice or action button) on the right. Sub-items fold in
+// and out with their parent.
+import QtQuick
+
+Item {
+    id: row
+    required property var modelData
+    required property int index
+    required property AppState app
+    readonly property var it: modelData
+    readonly property bool shown: !it.parent || !!app.want[it.parent]
+    readonly property int rowIndex: app.rows.findIndex(function (r) { return r.id === it.id; })
+    readonly property bool selected: shown && rowIndex === app.sel
+    readonly property bool on: !!app.want[it.id]
+    // Greyed out: an action with nothing to do, or an option this machine
+    // can't turn on.
+    readonly property bool unavailable: (it.kind === "action" && !(app.bios && app.bios.selectable)) || (it.kind === "toggle" && it.selectable === false)
+    readonly property string hint: it.id === "bios" ? app.biosHint()
+                                 : it.selectable === false ? it.hint
+                                 : ((Texts.items[it.id] || {}).hint || it.hint)
+
+    height: shown ? 62 : 0
+    opacity: shown ? 1 : 0
+    clip: true
+    Behavior on height { NumberAnimation { duration: 160; easing.type: Easing.OutCubic } }
+    Behavior on opacity { NumberAnimation { duration: 160 } }
+
+    Rectangle {
+        width: parent.width; height: 56; radius: 12
+        color: row.selected ? Theme.cardSel : Theme.card
+        border.width: row.selected ? 2 : 0; border.color: Theme.accent
+        MouseArea { anchors.fill: parent; cursorShape: Qt.PointingHandCursor
+            onClicked: { Input.type = "keyboard"; if (row.selected) app.act("accept"); else app.sel = row.rowIndex; } }
+
+        Text { visible: !!row.it.parent; x: 20; anchors.verticalCenter: parent.verticalCenter; text: "└"; color: "#56627a"; font.pixelSize: 18 }
+        Column {
+            anchors.verticalCenter: parent.verticalCenter; spacing: 2
+            x: row.it.parent ? 46 : 16
+            width: controls.x - x - 16
+            opacity: row.unavailable ? 0.6 : 1
+            Row { width: parent.width; spacing: 10
+                Text { text: app.label(row.it); color: Theme.textHi; font.family: Theme.body; font.pixelSize: 17; font.weight: Font.DemiBold; elide: Text.ElideRight
+                       width: Math.min(implicitWidth, parent.width - (badge.visible ? badge.width + parent.spacing : 0)) }
+                Badge { id: badge; update: !!row.it.update; isNew: !!row.it["new"]; anchors.verticalCenter: parent.verticalCenter } }
+            Text { text: row.hint; color: Theme.mute; font.family: Theme.body; font.pixelSize: 13; elide: Text.ElideRight; width: parent.width }
+        }
+
+        // Every control ends on the same edge.
+        Item {
+            id: controls
+            opacity: row.it.kind === "toggle" && row.it.selectable === false ? 0.4 : 1
+            anchors.right: parent.right; anchors.rightMargin: 16; anchors.verticalCenter: parent.verticalCenter
+            width: 180; height: 32
+            // choice
+            Rectangle { visible: row.it.kind === "choice"; anchors.right: parent.right; anchors.verticalCenter: parent.verticalCenter
+                width: 172; height: 32; radius: 10; color: Theme.bg
+                Row { anchors.centerIn: parent; spacing: 4
+                    Repeater { model: [["gamescope", "Gaming"], ["desktop", "Desktop"]]
+                        Rectangle { required property var modelData
+                            readonly property bool picked: app.boot === modelData[0]
+                            width: 80; height: 26; radius: 7; color: picked ? Theme.accent : "transparent"
+                            Text { anchors.centerIn: parent; text: parent.modelData[1]; color: parent.picked ? Theme.ink : Theme.mute
+                                   font.family: Theme.body; font.pixelSize: 13; font.weight: Font.DemiBold }
+                            MouseArea { anchors.fill: parent; onClicked: app.boot = parent.modelData[0] } } } } }
+            // toggle: "now on/off" left of the switch
+            Rectangle { id: sw; visible: row.it.kind === "toggle"; anchors.right: parent.right; anchors.verticalCenter: parent.verticalCenter
+                width: 46; height: 26; radius: 13; color: row.on ? Theme.accent : "#343f50"
+                Behavior on color { ColorAnimation { duration: 120 } }
+                Rectangle { width: 20; height: 20; radius: 10; color: "#f4f7fb"; y: 3; x: row.on ? 23 : 3; Behavior on x { NumberAnimation { duration: 120 } } } }
+            Text { visible: row.it.kind === "toggle"; anchors.right: sw.left; anchors.rightMargin: 12; anchors.verticalCenter: parent.verticalCenter
+                   text: row.it.on ? "now on" : "now off"; color: row.it.on ? Theme.good : Theme.faint; font.family: Theme.mono; font.pixelSize: 12 }
+            // action (Update BIOS)
+            Rectangle { visible: row.it.kind === "action"; anchors.right: parent.right; anchors.verticalCenter: parent.verticalCenter
+                width: at.implicitWidth + 24; height: 30; radius: 8; color: Theme.warnBg
+                Text { id: at; anchors.centerIn: parent; color: Theme.warn; font.family: Theme.body; font.pixelSize: 13; font.weight: Font.DemiBold
+                       text: app.biosChecking ? "Checking…" : app.bios && app.bios.selectable ? "Update…" : (app.bios && app.bios.newest ? "Up to date" : "Unavailable") } }
+        }
+    }
+}

ui/qml/MenuScreen.qml

@@ -0,0 +1,80 @@
+// The menu: every item on the left, what the selected one does and the
+// system on the right, Review & apply at the bottom.
+import QtQuick
+import QtQuick.Controls.Basic
+
+Item {
+    id: screen
+    required property AppState app
+    readonly property var g: Input.g
+
+    Text {
+        visible: app.items.length === 0
+        anchors.centerIn: parent; color: Theme.mute; font.family: Theme.body; font.pixelSize: 18
+        text: app.status.error ? "Couldn't read the current state:\n" + app.status.error : "Checking what's on…"
+        horizontalAlignment: Text.AlignHCenter
+    }
+
+    Item {
+        visible: app.items.length > 0
+        x: 40; y: 28; width: parent.width - 80; height: parent.height - 28 - 64 - 20
+        Column {
+            width: 740; height: parent.height; spacing: 10
+            Text { text: "What do you want?"; color: Theme.text; font.family: Theme.display; font.pixelSize: 30; font.weight: Font.DemiBold }
+            ListView {
+                id: list; width: parent.width; height: parent.height - 50; clip: true
+                // A fixed model: sub-items fold in and out instead of the
+                // list being rebuilt (and jumping) on every tick.
+                model: app.items
+                ScrollBar.vertical: ScrollBar { policy: ScrollBar.AsNeeded }
+                delegate: MenuRow {
+                    app: screen.app
+                    width: list.width - 12; x: 2
+                    onSelectedChanged: if (selected) Qt.callLater(list.positionViewAtIndex, index, ListView.Contain)
+                }
+            }
+        }
+        Column {
+            x: 772; width: parent.width - 772; height: parent.height; spacing: 16
+            DetailPanel { app: screen.app; width: parent.width; height: parent.height - sys.height - 16 }
+            Rectangle {
+                id: sys; width: parent.width; height: 82; radius: 16; color: Theme.card
+                Grid { anchors.fill: parent; anchors.margins: 16; anchors.leftMargin: 20; anchors.rightMargin: 20; columns: 2; columnSpacing: 20; rowSpacing: 10
+                    Repeater {
+                        model: [["Kernel", (app.status.kernel || "").replace("-cachyos", "")],
+                                ["LED bar", app.status.steamMachine ? (app.status.leds || 0) + " LEDs" : "—"],
+                                ["HDMI-CEC", app.status.cecDevices ? "/dev/" + app.status.cecDevices.split(" ")[0] : "none"],
+                                ["Version", app.status.version || ""]]
+                        Row { required property var modelData; width: (sys.width - 60) / 2
+                            Text { text: parent.modelData[0]; color: Theme.faint; font.family: Theme.body; font.pixelSize: 13; width: parent.width / 2 }
+                            Text { text: parent.modelData[1]; color: Theme.text; font.family: Theme.mono; font.pixelSize: 13; width: parent.width / 2
+                                   horizontalAlignment: Text.AlignRight; elide: Text.ElideLeft } }
+                    }
+                }
+            }
+        }
+    }
+
+    Bar {
+        Row {
+            anchors.left: parent.left; anchors.leftMargin: 40; anchors.verticalCenter: parent.verticalCenter; spacing: 28
+            Repeater {
+                // Quit only has a key on a keyboard (Ctrl+Q), and re-apply has
+                // none through Steam's layout; a controller quits through Steam.
+                model: [[screen.g.toggle, "Toggle"], [screen.g.choose, "Choose"], [screen.g.reapply, "Re-apply what's on"], [screen.g.quit, "Quit"]]
+                           .filter(function (h) { return h[0] !== ""; })
+                Row { required property var modelData; spacing: 8
+                    Glyph { k: parent.modelData[0]; anchors.verticalCenter: parent.verticalCenter }
+                    Text { text: parent.modelData[1]; color: Theme.label; font.family: Theme.body; font.pixelSize: 14; anchors.verticalCenter: parent.verticalCenter } }
+            }
+        }
+        Row {
+            anchors.right: parent.right; anchors.rightMargin: 40; anchors.verticalCenter: parent.verticalCenter; spacing: 16
+            Text { readonly property int n: app.computePlan().length
+                   text: n === 0 ? "Everything is the way you want it" : n + (n === 1 ? " change" : " changes")
+                   color: Theme.faint; font.family: Theme.body; font.pixelSize: 14; anchors.verticalCenter: parent.verticalCenter }
+            Btn { k: screen.g.apply; text: "Review & apply"; primary: true; enabled: app.canApply
+                  focusRing: app.sel === app.rows.length; height: 44; onClicked: app.goReview(false) }
+        }
+    }
+}

ui/qml/PasswordScreen.qml

@@ -0,0 +1,57 @@
+// The sudo password, asked once per run; never stored.
+import QtQuick
+import QtQuick.Controls.Basic
+
+Rectangle {
+    id: screen
+    required property AppState app
+    color: "#0c1016"
+    function submit() { var p = pw.text; pw.text = ""; app.submitPassword(p); }
+
+    Connections {
+        target: screen.app
+        function onPasswordRequested() { pw.text = ""; pw.shown = false; pw.forceActiveFocus(); }
+        function onPasswordRejected() { pw.forceActiveFocus(); }
+        function onPasswordSubmitRequested() { screen.submit(); }
+    }
+    Binding { target: screen.app; property: "typing"; value: pw.activeFocus; when: screen.visible }
+
+    Rectangle {
+        anchors.centerIn: parent; width: 560; height: col.implicitHeight + 72; radius: 20; color: Theme.card; border.width: 1; border.color: Theme.line
+        Column {
+            id: col; anchors.fill: parent; anchors.margins: 36; anchors.leftMargin: 40; anchors.rightMargin: 40; spacing: 18
+            Row { spacing: 14
+                Rectangle { width: 48; height: 48; radius: 14; color: Theme.infoBg
+                    // A padlock.
+                    Canvas { anchors.centerIn: parent; width: 24; height: 24
+                        onPaint: { var c = getContext("2d"); c.strokeStyle = Theme.info; c.lineWidth = 1.8; c.beginPath(); c.roundedRect(4.5, 10.5, 15, 10, 2.5, 2.5); c.stroke();
+                                   c.beginPath(); c.moveTo(8, 10.5); c.lineTo(8, 8); c.arc(12, 8, 4, Math.PI, 0); c.lineTo(16, 10.5); c.stroke(); } } }
+                Column { spacing: 2; anchors.verticalCenter: parent.verticalCenter
+                    Text { text: "Your password, once"; color: Theme.text; font.family: Theme.display; font.pixelSize: 30; font.weight: Font.DemiBold }
+                    Text { text: "Steamify needs it to change system settings."; color: Theme.mute; font.family: Theme.body; font.pixelSize: 14 } }
+            }
+            Text { text: "Password for " + app.backend.user(); color: Theme.soft; font.family: Theme.body; font.pixelSize: 14; font.weight: Font.DemiBold }
+            TextField {
+                id: pw; width: parent.width; height: 52; echoMode: shown ? TextInput.Normal : TextInput.Password
+                property bool shown: false
+                color: Theme.textHi; font.family: Theme.body; font.pixelSize: 18; leftPadding: 16; rightPadding: 56
+                placeholderText: "Password"; placeholderTextColor: "#6b778a"
+                background: Rectangle { radius: 12; color: Theme.bg; border.width: 2; border.color: app.wrongPassword ? Theme.bad : Theme.accent }
+                Keys.onReturnPressed: screen.submit()
+                Keys.onEnterPressed: screen.submit()
+                Keys.onEscapePressed: app.act("back")
+                Text { anchors.right: parent.right; anchors.rightMargin: 16; anchors.verticalCenter: parent.verticalCenter; text: pw.shown ? "Hide" : "Show"
+                       color: Theme.label; font.family: Theme.body; font.pixelSize: 13
+                    MouseArea { anchors.fill: parent; anchors.margins: -10; onClicked: pw.shown = !pw.shown } }
+            }
+            Text { visible: app.wrongPassword; text: "That password didn't work. Try again."; color: Theme.bad; font.family: Theme.body; font.pixelSize: 14 }
+            Rectangle { width: parent.width; height: 46; radius: 12; color: Theme.note
+                Text { anchors.verticalCenter: parent.verticalCenter; x: 14; color: Theme.soft; font.family: Theme.body; font.pixelSize: 14
+                       text: ({ controller: "Press Steam + X for the on-screen keyboard.", keyboard: "Type your password and press Enter.", steam: "Press X for Steam's on-screen keyboard, type your password and press A.", remote: "Select the field for the on-screen keyboard." })[Input.type] } }
+            Item { width: parent.width; height: 48
+                Btn { k: Input.g.back; text: "Back"; onClicked: app.act("back") }
+                Btn { anchors.right: parent.right; k: Input.g.ok; text: "Apply"; primary: true; onClicked: screen.submit() } }
+            Text { text: "Only used for this run. Steamify never stores it."; color: Theme.faint; font.family: Theme.body; font.pixelSize: 12; anchors.horizontalCenter: parent.horizontalCenter }
+        }
+    }
+}

ui/qml/ReviewScreen.qml

@@ -0,0 +1,49 @@
+// What a run will change, with a summary; Apply asks for the password.
+import QtQuick
+import QtQuick.Controls.Basic
+
+Item {
+    required property AppState app
+    Column {
+        x: 40; y: 32; width: 740; spacing: 14
+        Text { text: app.plan.length === 0 ? "Nothing to change" : "This will"; color: Theme.text; font.family: Theme.display; font.pixelSize: 34; font.weight: Font.DemiBold }
+        ListView {
+            width: 740; clip: true; spacing: 8
+            height: Math.min(contentHeight, parent.parent.height - 32 - 50 - 14 - 66 - 64 - 32)
+            model: app.plan
+            ScrollBar.vertical: ScrollBar { policy: ScrollBar.AsNeeded }
+            delegate: Rectangle {
+                id: step
+                required property var modelData
+                readonly property var st: Texts.actions[modelData.action] || ["", Theme.text, Theme.card]
+                width: 740; height: 56; radius: 12; color: Theme.card
+                Row { anchors.fill: parent; anchors.leftMargin: 18; spacing: 14
+                    Chip { text: step.st[0]; fg: step.st[1]; bgc: step.st[2]; width: 84; anchors.verticalCenter: parent.verticalCenter }
+                    Text { text: Texts.label(step.modelData.id); color: Theme.textHi; font.family: Theme.body; font.pixelSize: 17; font.weight: Font.DemiBold
+                           anchors.verticalCenter: parent.verticalCenter }
+                    Badge { isNew: !!step.modelData.isNew; anchors.verticalCenter: parent.verticalCenter }
+                }
+            }
+        }
+        Rectangle { width: 740; height: 52; radius: 12; color: Theme.note
+            Text { anchors.verticalCenter: parent.verticalCenter; x: 18; text: "Your password is asked once. Changes to how the PC starts need a restart."
+                   color: Theme.soft; font.family: Theme.body; font.pixelSize: 14 } }
+    }
+    Rectangle {
+        x: parent.width - 468; y: 32; width: 428; height: 250; radius: 16; color: Theme.card
+        Column { anchors.fill: parent; anchors.margins: 24; spacing: 12
+            Text { text: "SUMMARY"; color: Theme.faint; font.family: Theme.body; font.pixelSize: 12; font.weight: Font.DemiBold; font.letterSpacing: 0.8 }
+            Repeater { model: [["Turn on", "on"], ["Update", "update"], ["Re-apply", "again"], ["Turn off", "off"]]
+                Row { required property var modelData; width: 380
+                    Text { text: parent.modelData[0]; color: Theme.soft; font.family: Theme.body; font.pixelSize: 15; width: 300 }
+                    Text { readonly property string action: parent.modelData[1]
+                           text: app.plan.filter(function (p) { return p.action === action; }).length
+                           color: Theme.text; font.family: Theme.mono; font.pixelSize: 15; width: 80; horizontalAlignment: Text.AlignRight } } }
+        }
+    }
+    Bar {
+        Btn { anchors.left: parent.left; anchors.leftMargin: 40; anchors.verticalCenter: parent.verticalCenter; k: Input.g.back; text: "Back to the menu"; onClicked: app.act("back") }
+        Btn { anchors.right: parent.right; anchors.rightMargin: 40; anchors.verticalCenter: parent.verticalCenter; k: Input.g.ok; text: "Apply"; primary: true
+              visible: app.plan.length > 0; onClicked: app.onApplyPressed() }
+    }
+}

ui/qml/RiskList.qml

@@ -0,0 +1,17 @@
+// The BIOS update's risks.
+import QtQuick
+
+Column {
+    id: list
+    spacing: 8
+    Repeater {
+        model: ["A failed or interrupted BIOS update can leave the machine unable to start (bricked). Steamify, CachyOS and Valve take no responsibility for that.",
+                "NEVER turn off the power, unplug the machine or press the power button while it updates, including the restart(s) afterwards.",
+                "The screen can stay black for several minutes. Wait.",
+                "Only on mains power, with all other programs closed."]
+        Row { required property string modelData; spacing: 10; width: list.width
+            Rectangle { width: 6; height: 6; radius: 3; color: Theme.bad; y: 9 }
+            Text { text: parent.modelData; width: parent.width - 16; wrapMode: Text.WordWrap; color: Theme.soft
+                   font.family: Theme.body; font.pixelSize: 15; lineHeight: 1.3 } }
+    }
+}

ui/qml/Texts.qml

@@ -0,0 +1,73 @@
+// Texts per item; the backend's labels are the fallback.
+pragma Singleton
+import QtQuick
+
+QtObject {
+    readonly property var items: ({
+        gaming: { label: "SteamOS conversion", hint: "Boot into gaming mode, Steam on the desktop",
+                  body: "Boots straight into gaming mode. Switch to Desktop in Steam works, and Return to Gaming Mode on the desktop brings you back.",
+                  changes: ["Autologin into gamescope", "Return to Gaming Mode shortcut", "Steam starts silently on the desktop"] },
+        boot: { label: "Boot into", hint: "Where the PC starts",
+                body: "Where the PC starts after a restart. Switching back and forth works the same either way.",
+                changes: ["Desktop: the Plasma session is set before login", "Gaming: the SteamOS default"] },
+        theme: { label: "SteamOS theme", hint: "Vapor look for the desktop, Add to Steam",
+                 body: "The Vapor look of SteamOS for the desktop, with its panel, launcher icon and wallpaper.",
+                 changes: ["cachyos-vapor global theme", "Add to Steam in right-click menus", "Nested Desktop, Steam keyboard window rule"] },
+        glyphs: { label: "Steam Deck/Machine icons", hint: "Deck button icons in gaming mode",
+                  body: "Steam shows Steam Deck button icons in gaming mode.", changes: ["STEAM_GAMEPADUI_ARGS -steamos3"] },
+        single: { label: "Single user mode", hint: "No password, lock screen or wallet prompts",
+                  body: "Like SteamOS: never a login or lock screen, and no KDE wallet password prompts. Typing a password with a controller is no fun.",
+                  changes: ["SDDM autologin, no lock screen or user switching", "Valve's empty wallet; your own is kept aside", "Launcher shows Sleep, Restart, Shut Down only"] },
+        launcher: { label: "Steamify shortcut", hint: "The app on the desktop and in the launcher",
+                    body: "Opens the newest Steamify app, so you never need the install command again. Steamify Terminal in the launcher opens the terminal menu.",
+                    changes: ["Steamify CachyOS on the desktop and in the launcher (the app)", "Steamify Terminal in the launcher"] },
+        steamgame: { label: "Add as non-Steam game", hint: "Steamify in your Steam library",
+                     body: "Adds Steamify to your Steam library as a non-Steam game. Started from Steam it gets your controller (a Steam Controller only talks to Steam while Steam runs), and you can open it in gaming mode. Steam closes for a moment and starts again, since it only reads its games list at startup: so this is done from the desktop, not from gaming mode or with Steamify started from Steam.",
+                     changes: ["Steamify CachyOS in your Steam library, with its icon", "An entry that's already there is updated, not added twice", "Off (or the shortcut off): removed from the library again"] },
+        notify: { label: "Update notifications", hint: "A notification when there's a new Steamify",
+                  body: "Checks once a day and when you log in to the desktop. When there's a new Steamify you get a notification and a tray icon: open the app to see what's new and choose what to update, or skip that version. It never updates anything by itself.",
+                  changes: ["A daily check (systemd user timer), only on the desktop", "Tray icon only while an update is waiting", "Skip this version: quiet until the next one"] },
+        vram: { label: "VRAM booster", hint: "The game in front keeps its VRAM",
+                body: "Like SteamOS 3.9: the game you're playing keeps its video memory, and background apps are moved out first. Without it a game that needs most of the video memory can spill into system RAM and stutter. Shown for GPUs whose driver supports it (AMD, Intel, NVIDIA with its open kernel modules from driver 615) on kernel 7.2 or newer.",
+                changes: ["dmemcg-booster (system and user service)", "plasma-foreground-booster, which tells it which window is in front", "Off: removed again, unless you had installed them yourself"] },
+        cec: { label: "HDMI-CEC", hint: "Use Steam with the TV remote, TV on/off with the PC", experimental: true,
+               body: "Use Steam with your TV remote, and the TV turns on and off with the PC. Turn on CEC on the TV too (Sony: BRAVIA Sync, Samsung: Anynet+, LG: SimpLink).",
+               changes: ["Valve's cecd and cec-audio-control", "HDMI CEC section in Steam's Display settings", "Volume buttons for the TV in the Quick Access menu"] },
+        machine: { label: "Steam Machine support", hint: "LED bar, fan and performance settings in Steam",
+                   body: "The front LED bar works, Steam's hardware settings work, and the power button puts it to sleep like a console.",
+                   changes: ["leds-valve driver for every kernel (DKMS)", "steamos-manager for Steam's settings", "Console-like power handling"] },
+        poweroff: { label: "Power-off fix", hint: "Stays off after shutting down",
+                    body: "With recent kernels the Steam Machine starts again right after shutting down: the firmware leaves a wake bit set, and newer kernels (7.2, and updates of 6.x, 7.0 and 7.1) no longer clear it. Valve's own kernel clears it; this small module does the same right before power-off.",
+                    changes: ["steamify-fremont-poweroff module for each installed kernel (DKMS)", "Only on a Steam Machine, only touches that one wake bit", "Off: recent kernels may start it again after shutting down"] },
+        kpin: { label: "Pin the kernel", hint: "No longer needed: untick for CachyOS's current kernel",
+                body: "Kept the Steam Machine on CachyOS kernel 7.1.6, which powered off properly. The power-off fix does that on every kernel now, so the pin is removed and CachyOS's current kernel comes back.",
+                changes: ["Removed from IgnorePkg", "linux-cachyos updated to CachyOS's current version"] },
+        hdmi: { label: "HDMI refresh boost", hint: "No longer needed: removed",
+                body: "Made HDMI displays run above 60 Hz on the pinned kernel. Current kernels do that themselves, so what's left of it is removed and every display uses its own EDID again.",
+                changes: ["Saved display EDIDs and the hotplug service removed", "The old kernel parameter removed, if it's still there"] },
+        bios: { label: "Update BIOS", hint: "",
+                body: "Installs Valve's newest Steam Machine BIOS, at your own risk. It checks Valve's checksum and asks fwupd whether the file fits this machine, then warns you twice before anything is written.",
+                changes: ["Valve's fremont-hw-support package (checksum checked)", "fwupd writes the BIOS during the next restart", "Keep the power on until the machine has fully started again"] }
+    })
+    // Replaces the explanation of an option that can't be turned on here.
+    readonly property var unsupported: ({
+        // The body comes from the backend (item.note): it depends on the driver.
+        vram: { changes: ["Nothing until then"] }
+    })
+
+    // Per plan action: the review's chip [text, colour, background] and the
+    // progress screen's verb.
+    readonly property var actions: ({
+        on: ["Turn on", Theme.good, Theme.goodBg, "Turn on "], off: ["Turn off", Theme.bad, Theme.badBg, "Turn off "],
+        again: ["Re-apply", Theme.info, Theme.infoBg, "Re-apply "], update: ["Update", Theme.warn, Theme.warnBg, ""],
+        desktop: ["Desktop", Theme.info, Theme.infoBg, "Boot into "], gaming: ["Gaming", Theme.info, Theme.infoBg, "Boot into "],
+        check: ["Check", Theme.warn, Theme.warnBg, "Download and check the "], flash: ["Flash", Theme.bad, Theme.badBg, "Hand to fwupd: the "]
+    })
+
+    function of(item) {
+        var tx = items[item.id] || {};
+        if (item.selectable !== false || !unsupported[item.id]) return tx;
+        return Object.assign({}, tx, unsupported[item.id], item.note ? { body: item.note } : {});
+    }
+    function label(id, fallback) { return (items[id] || {}).label || fallback || id; }
+}

ui/qml/Theme.qml

@@ -0,0 +1,36 @@
+// Colours and fonts (from the design).
+pragma Singleton
+import QtQuick
+
+QtObject {
+    readonly property color bg: "#0f1319"
+    readonly property color bar: "#141a22"
+    readonly property color line: "#232c38"
+    readonly property color card: "#161d27"
+    readonly property color cardSel: "#1f2a3a"
+    readonly property color text: "#e6ebf2"
+    readonly property color textHi: "#eef2f7"
+    readonly property color soft: "#c3ccd8"
+    readonly property color mute: "#97a3b4"
+    readonly property color faint: "#8b97a8"
+    readonly property color label: "#b8c3d1"
+    readonly property color accent: "#3ea6ff"
+    readonly property color ink: "#06121f"
+    readonly property color good: "#7fd1a8"
+    readonly property color goodBg: "#173226"
+    readonly property color warn: "#f2a33a"
+    readonly property color warnBg: "#2a2116"
+    readonly property color bad: "#ff9a8a"
+    readonly property color badBg: "#2a1c1c"
+    readonly property color info: "#7cc4ff"
+    readonly property color infoBg: "#1b2b40"
+    readonly property color note: "#1a2230"
+    readonly property color key: "#2a3444"
+    readonly property color button: "#232c38"
+    readonly property color danger: "#8a2c2c"
+    readonly property color dangerBg: "#1d1416"
+    readonly property color dangerLine: "#b33a3a"
+    readonly property string display: "Barlow Semi Condensed"
+    readonly property string body: "IBM Plex Sans"
+    readonly property string mono: "IBM Plex Mono"
+}

ui/qml/qmldir

@@ -0,0 +1,20 @@
+singleton Theme 1.0 Theme.qml
+singleton Texts 1.0 Texts.qml
+singleton Input 1.0 Input.qml
+AppState 1.0 AppState.qml
+Glyph 1.0 Glyph.qml
+Btn 1.0 Btn.qml
+Chip 1.0 Chip.qml
+Badge 1.0 Badge.qml
+Bar 1.0 Bar.qml
+RiskList 1.0 RiskList.qml
+Header 1.0 Header.qml
+MenuRow 1.0 MenuRow.qml
+DetailPanel 1.0 DetailPanel.qml
+MenuScreen 1.0 MenuScreen.qml
+ReviewScreen 1.0 ReviewScreen.qml
+PasswordScreen 1.0 PasswordScreen.qml
+ApplyingScreen 1.0 ApplyingScreen.qml
+BiosWarningScreen 1.0 BiosWarningScreen.qml
+BiosConfirmScreen 1.0 BiosConfirmScreen.qml
+DoneScreen 1.0 DoneScreen.qml

ui/steamify-app.sh

@@ -0,0 +1,79 @@
+#!/bin/bash
+# Steamify CachyOS - get and start the app (v2), for `curl | bash`:
+#   curl -fsSL https://github.com/theupriser/steamify-cachyos/releases/latest/download/steamify-app.sh | bash
+# Downloads the newest release's app package (steamify-app.tar.gz: the app,
+# steamify.sh, lib/, patches/ and services/) to ~/.local/share/steamify/app, installs PySide6 if
+# it's missing, adds a launcher entry, and starts the app.
+# STEAMIFY_RELEASE=<tag> takes that release instead of the newest (the
+# v2-ui-preview build's copy of this script sets it). STEAMIFY_BRANCH=<branch>
+# takes that branch's source instead (for testing before a build).
+set -euo pipefail
+
+REPO="theupriser/steamify-cachyos"
+RELEASE="${STEAMIFY_RELEASE:-latest}"
+DEST="${XDG_DATA_HOME:-$HOME/.local/share}/steamify/app"
+APPS="${XDG_DATA_HOME:-$HOME/.local/share}/applications"
+
+say() { printf '\033[36m[INFO]\033[0m %s\n' "$*"; }
+die() { printf '\033[31m[ERROR] %s\033[0m\n' "$*" >&2; exit 1; }
+
+[[ $EUID -ne 0 ]] || die "Run this as your normal user, not as root."
+command -v pacman >/dev/null || die "This is for CachyOS/Arch (no pacman found)."
+
+tmp="$(mktemp -d)"; trap 'rm -rf "$tmp"' EXIT
+if [[ -n "${STEAMIFY_BRANCH:-}" ]]; then
+    say "Downloading Steamify from the $STEAMIFY_BRANCH branch..."
+    curl -fsSL "https://github.com/$REPO/archive/refs/heads/$STEAMIFY_BRANCH.tar.gz" -o "$tmp/src.tar.gz" ||
+        die "Couldn't download the $STEAMIFY_BRANCH branch."
+    mkdir "$tmp/app"
+    tar -xzf "$tmp/src.tar.gz" -C "$tmp/app" --strip-components=1
+else
+    if [[ "$RELEASE" == latest ]]; then
+        url="https://github.com/$REPO/releases/latest/download/steamify-app.tar.gz"
+        say "Downloading the newest Steamify app..."
+    else
+        url="https://github.com/$REPO/releases/download/$RELEASE/steamify-app.tar.gz"
+        say "Downloading the Steamify app ($RELEASE)..."
+    fi
+    curl -fsSL "$url" -o "$tmp/app.tar.gz" ||
+        die "Couldn't download the app (is there a release with steamify-app.tar.gz yet?)."
+    mkdir "$tmp/app"
+    tar -xzf "$tmp/app.tar.gz" -C "$tmp/app"
+fi
+[[ -x "$tmp/app/ui/steamify-ui" && -f "$tmp/app/steamify.sh" ]] || die "The download doesn't contain the app."
+
+mkdir -p "$(dirname "$DEST")"
+rm -rf "$DEST.new"; mv "$tmp/app" "$DEST.new"
+rm -rf "$DEST"; mv "$DEST.new" "$DEST"
+say "Installed to $DEST ($(grep -m1 -oP '^VERSION=\K.*' "$DEST/steamify.sh"))."
+
+if ! python3 -c 'import PySide6.QtQml' 2>/dev/null; then
+    say "The app needs PySide6 (Qt for Python); installing it..."
+    # Piped in via curl, stdin isn't the terminal: sudo asks on it anyway.
+    sudo pacman -S --needed --noconfirm pyside6 </dev/tty || die "Installing pyside6 failed."
+fi
+
+# Launcher entry (its id also names the app to the desktop portal). The
+# Steamify shortcut's entry has the same id and always starts the newest
+# release: left alone.
+mkdir -p "$APPS"
+grep -q '^X-Steamify-Shortcut=true' "$APPS/steamify-ui.desktop" 2>/dev/null ||
+cat > "$APPS/steamify-ui.desktop" << EOF
+[Desktop Entry]
+Type=Application
+Name=Steamify CachyOS
+Comment=Turn this PC into a SteamOS-style console
+Exec=$DEST/ui/steamify-ui
+Icon=$DEST/assets/steam-gaming-settings.svg
+Terminal=false
+Categories=Game;Settings;
+EOF
+command -v update-desktop-database >/dev/null && update-desktop-database "$APPS" 2>/dev/null || true
+
+say "Starting Steamify..."
+# Started from Steam: stay in the foreground, or Steam counts the game as
+# ended right away and stops giving it the controller.
+if [[ -n "${SteamGameId:-}" ]]; then
+    exec "$DEST/ui/steamify-ui" < /dev/null
+fi
+setsid "$DEST/ui/steamify-ui" >/dev/null 2>&1 < /dev/null &

ui/steamify-ui

@@ -0,0 +1,389 @@
+#!/usr/bin/env python3
+"""Steamify CachyOS - graphical app (v2).
+
+A controller-, TV remote- and keyboard-friendly front end for steamify.sh:
+the components and their logic stay in lib/*.sh, reached through
+`steamify.sh --backend status|apply` (lib/backend.sh). Needs PySide6
+(pacman -S pyside6).
+
+    steamify-ui [--windowed|--fullscreen]
+"""
+
+import json
+import os
+import select
+import shutil
+import stat
+import struct
+import sys
+import tempfile
+import threading
+import time
+
+# Started from Steam (a non-Steam game, so Steam Input hands it the
+# controller): Steam preloads its overlay into every game, and Qt aborts with
+# it loaded. Start again without it, before Qt is imported.
+if "gameoverlayrenderer" in os.environ.get("LD_PRELOAD", ""):
+    os.environ["LD_PRELOAD"] = ":".join(p for p in os.environ["LD_PRELOAD"].split(":")
+                                        if p and "gameoverlayrenderer" not in p)
+    os.execv(sys.executable, [sys.executable] + sys.argv)
+
+HERE = os.path.dirname(os.path.realpath(__file__))
+
+try:
+    from PySide6.QtCore import (QObject, QProcess, QProcessEnvironment,
+                                Property, Signal, Slot, QUrl, SLOT)
+    from PySide6.QtGui import QGuiApplication, QIcon
+    from PySide6.QtQml import QQmlApplicationEngine
+    from PySide6.QtDBus import QDBusConnection
+except ImportError:
+    msg = ("Steamify's app needs PySide6 (Qt for Python).\n"
+           "Install it with:  sudo pacman -S pyside6\n"
+           "or run the terminal version: steamify.sh")
+    print(msg, file=sys.stderr)
+    if shutil.which("kdialog"):
+        os.system("kdialog --title Steamify --sorry " + json.dumps(msg))
+    sys.exit(1)
+
+
+def find_script():
+    """steamify.sh next to the app: the repository (../steamify.sh) or an
+    install that keeps both in one folder."""
+    for p in (os.path.join(HERE, "..", "steamify.sh"),
+              os.path.join(HERE, "steamify.sh")):
+        if os.path.isfile(p):
+            return os.path.realpath(p)
+    return None
+
+
+# --- Controller input -------------------------------------------------------
+# Qt 6 has no gamepad module: read the evdev device directly. Controllers
+# are tagged uaccess, so the logged-in user may read them.
+
+EV_KEY, EV_ABS = 0x01, 0x03
+BUTTONS = {0x130: "a", 0x131: "b", 0x133: "y", 0x134: "x",  # SOUTH EAST NORTH WEST
+           0x13a: "select", 0x13b: "start", 0x13c: "guide",
+           0x220: "up", 0x221: "down", 0x222: "left", 0x223: "right"}  # BTN_DPAD_*
+ABS_X, ABS_Y, ABS_HAT0X, ABS_HAT0Y = 0x00, 0x01, 0x10, 0x11
+EVENT = struct.Struct("llHHi")
+
+
+def controller_devices():
+    """/dev/input/eventN of every device that has a gamepad's south button."""
+    found = []
+    base = "/sys/class/input"
+    for name in sorted(os.listdir(base)):
+        if not name.startswith("event"):
+            continue
+        try:
+            with open(os.path.join(base, name, "device", "capabilities", "key")) as f:
+                words = f.read().split()
+        except OSError:
+            continue
+        bits = 0
+        for w in words:
+            bits = (bits << 64) | int(w, 16)
+        if bits >> 0x130 & 1:
+            found.append("/dev/input/" + name)
+    return found
+
+
+class Gamepad(QObject):
+    """Emits button("a"|"b"|"x"|"y"|"up"|...) from any controller, and
+    "<name>_up" when a button is released."""
+    button = Signal(str)
+
+    def __init__(self):
+        super().__init__()
+        self._stop = False
+        threading.Thread(target=self._run, daemon=True).start()
+
+    def _run(self):
+        files = {}
+        stick = {ABS_X: 0, ABS_Y: 0}
+        last_scan = 0
+        while not self._stop:
+            if time.time() - last_scan > 2:  # plugged in or out
+                last_scan = time.time()
+                for path in controller_devices():
+                    if path not in files:
+                        try:
+                            files[path] = open(path, "rb", buffering=0)
+                        except OSError:
+                            pass
+            if not files:
+                time.sleep(0.5)
+                continue
+            try:
+                ready, _, _ = select.select(list(files.values()), [], [], 0.5)
+            except (OSError, ValueError):
+                ready = []
+            for f in ready:
+                try:
+                    data = f.read(EVENT.size * 32)
+                except OSError:
+                    data = b""
+                if not data:
+                    files = {p: x for p, x in files.items() if x is not f}
+                    continue
+                for off in range(0, len(data) - EVENT.size + 1, EVENT.size):
+                    _, _, typ, code, value = EVENT.unpack_from(data, off)
+                    if typ == EV_KEY and code in BUTTONS and value in (0, 1):
+                        # Presses as "a"; releases as "a_up" (the BIOS
+                        # confirmation is a 5-second hold).
+                        self.button.emit(BUTTONS[code] + ("" if value else "_up"))
+                    elif typ == EV_ABS and code in (ABS_HAT0X, ABS_HAT0Y) and value:
+                        self.button.emit({(ABS_HAT0X, -1): "left", (ABS_HAT0X, 1): "right",
+                                          (ABS_HAT0Y, -1): "up", (ABS_HAT0Y, 1): "down"}[(code, value)])
+                    elif typ == EV_ABS and code in stick:
+                        # Left stick as a D-pad: one step per push past half-way.
+                        was = stick[code]
+                        now = -1 if value < -16000 else (1 if value > 16000 else 0)
+                        stick[code] = now
+                        if now and not was:
+                            self.button.emit({(ABS_X, -1): "left", (ABS_X, 1): "right",
+                                              (ABS_Y, -1): "up", (ABS_Y, 1): "down"}[(code, now)])
+
+
+# --- Backend ----------------------------------------------------------------
+
+class Backend(QObject):
+    statusChanged = Signal()
+    event = Signal("QVariant")          # one parsed JSON event from apply
+    busyChanged = Signal()
+    remotePressed = Signal()           # a key from the TV remote (cecd)
+
+    def __init__(self, script):
+        super().__init__()
+        self._script = script
+        self._status = {}
+        self._busy = False
+        self._proc = None
+        self._buf = b""
+        self._secret_dir = None
+        # The TV remote's keys reach Qt as keys; cecd also announces them on
+        # D-Bus, which tells the app they came from the remote.
+        try:
+            QDBusConnection.sessionBus().connect(
+                "com.steampowered.CecDaemon1", "", "com.steampowered.CecDaemon1.CecDevice1",
+                "UserControlPressed", self, SLOT("_on_remote()"))
+        except Exception as e:  # no remote detection; keys still work
+            print("steamify-ui: no CEC remote detection:", e, file=sys.stderr)
+
+    @Slot()
+    def _on_remote(self):
+        self.remotePressed.emit()
+
+    def _get_status(self):
+        return self._status
+
+    status = Property("QVariant", _get_status, notify=statusChanged)
+
+    def _get_busy(self):
+        return self._busy
+
+    busy = Property(bool, _get_busy, notify=busyChanged)
+
+    @Slot(result=str)
+    def user(self):
+        return os.environ.get("USER") or os.getlogin()
+
+    @Slot()
+    def refresh(self):
+        p = QProcess(self)
+        p.setProgram("bash")
+        p.setArguments([self._script, "--backend", "status"])
+
+        def done(*_):
+            try:
+                self._status = json.loads(bytes(p.readAllStandardOutput()).decode())
+            except ValueError:
+                self._status = {"error": bytes(p.readAllStandardError()).decode()[-500:]}
+            self.statusChanged.emit()
+            p.deleteLater()
+        p.finished.connect(done)
+        p.start()
+
+    def _make_askpass(self, password):
+        """A private folder with a helper that `sudo -A` runs for the
+        password, and a `sudo` that always uses it (makepkg and yay call
+        plain sudo). The password is never written to a file: the helper
+        reads it from a named pipe, and the app writes it into the pipe from
+        memory each time sudo asks, until _drop_askpass."""
+        base = os.environ.get("XDG_RUNTIME_DIR") or tempfile.gettempdir()
+        d = tempfile.mkdtemp(prefix="steamify-", dir=base)
+        os.chmod(d, stat.S_IRWXU)
+        pipe = os.path.join(d, "pipe")
+        os.mkfifo(pipe, 0o600)
+        askpass = os.path.join(d, "askpass")
+        with open(askpass, "w") as f:
+            f.write("#!/bin/sh\nexec cat %s\n" % json.dumps(pipe))
+        os.chmod(askpass, 0o700)
+        bindir = os.path.join(d, "bin")
+        os.mkdir(bindir)
+        wrapper = os.path.join(bindir, "sudo")
+        with open(wrapper, "w") as f:
+            f.write("#!/bin/sh\nexec /usr/bin/sudo -A \"$@\"\n")
+        os.chmod(wrapper, 0o700)
+        stop = threading.Event()
+        data = (password + "\n").encode()
+
+        def serve():
+            while not stop.is_set():
+                try:
+                    fd = os.open(pipe, os.O_WRONLY)  # waits for a reader
+                except OSError:
+                    return
+                try:
+                    if not stop.is_set():
+                        os.write(fd, data)
+                except OSError:
+                    pass
+                finally:
+                    os.close(fd)
+        threading.Thread(target=serve, daemon=True).start()
+        self._askpass_stop = (stop, pipe)
+        return d, askpass, bindir
+
+    def _drop_askpass(self):
+        if getattr(self, "_askpass_stop", None):
+            stop, pipe = self._askpass_stop
+            self._askpass_stop = None
+            stop.set()
+            try:  # wakes the writer waiting for a reader, which then ends
+                os.close(os.open(pipe, os.O_RDONLY | os.O_NONBLOCK))
+            except OSError:
+                pass
+        if self._secret_dir:
+            shutil.rmtree(self._secret_dir, ignore_errors=True)
+            self._secret_dir = None
+
+    def _start(self, args, password):
+        if self._busy:
+            return
+        env = QProcessEnvironment.systemEnvironment()
+        if password:
+            self._secret_dir, askpass, bindir = self._make_askpass(password)
+            env.insert("SUDO_ASKPASS", askpass)
+            env.insert("PATH", bindir + ":" + env.value("PATH"))
+        p = QProcess(self)
+        p.setProcessEnvironment(env)
+        p.setProcessChannelMode(QProcess.MergedChannels)
+        p.setProgram("bash")
+        p.setArguments([self._script, "--backend"] + args)
+        self._buf = b""
+        p.readyReadStandardOutput.connect(lambda: self._read(p))
+        p.finished.connect(lambda *_: self._finished(p))
+        self._proc = p
+        self._busy = True
+        self.busyChanged.emit()
+        p.start()
+
+    @Slot("QVariant", str, bool, str)
+    def apply(self, ids, boot, reapply, password):
+        try:
+            if hasattr(ids, "toVariant"):  # a JS array from QML
+                ids = ids.toVariant()
+            args = ["apply"]
+            if reapply:
+                args.append("--reapply")
+            if boot:
+                args += ["--boot", boot]
+            self._start(args + [str(i) for i in (ids or [])], password)
+        except Exception as e:
+            # Never leave the app on the progress screen.
+            print("steamify-ui: couldn't start:", e, file=sys.stderr)
+            self._drop_askpass()
+            self.event.emit({"event": "finished", "failed": [], "restart": False, "error": "start"})
+
+    @Slot(str)
+    def biosPrepare(self, password):
+        """Download, checksum, fwupd check: ends with a bios-ready event."""
+        self._start(["bios-prepare"], password)
+
+    @Slot(str)
+    def biosFlash(self, password):
+        """Only after both warnings in the app."""
+        self._start(["bios-flash"], password)
+
+    def _read(self, p):
+        self._buf += bytes(p.readAllStandardOutput())
+        while b"\n" in self._buf:
+            line, self._buf = self._buf.split(b"\n", 1)
+            text = line.decode(errors="replace")
+            try:
+                ev = json.loads(text)
+            except ValueError:
+                ev = {"event": "log", "id": "", "line": text}
+            if isinstance(ev, dict):
+                self.event.emit(ev)
+
+    def _finished(self, p):
+        self._read(p)
+        self._drop_askpass()
+        self._busy = False
+        self.busyChanged.emit()
+        p.deleteLater()
+        self.refresh()
+
+    @Slot(str, result=bool)
+    def checkPassword(self, password):
+        """True if sudo accepts the password (or needs none)."""
+        import subprocess
+        if subprocess.run(["sudo", "-n", "true"], capture_output=True).returncode == 0:
+            return True
+        r = subprocess.run(["sudo", "-S", "-k", "-p", "", "true"],
+                           input=(password + "\n").encode(), capture_output=True)
+        return r.returncode == 0
+
+    @Slot(result=bool)
+    def needsPassword(self):
+        import subprocess
+        return subprocess.run(["sudo", "-n", "true"], capture_output=True).returncode != 0
+
+    @Slot()
+    def restart(self):
+        QProcess.startDetached("systemctl", ["reboot"])
+
+    def shutdown(self):
+        if self._proc and self._proc.state() != QProcess.NotRunning:
+            self._proc.kill()
+            self._proc.waitForFinished(3000)
+        self._drop_askpass()
+
+
+def main():
+    script = find_script()
+    if not script:
+        print("steamify-ui: can't find steamify.sh next to the app.", file=sys.stderr)
+        return 1
+    in_gamescope = bool(os.environ.get("GAMESCOPE_WAYLAND_DISPLAY")) or \
+        os.environ.get("XDG_CURRENT_DESKTOP", "").lower() == "gamescope"
+    fullscreen = "--fullscreen" in sys.argv or (in_gamescope and "--windowed" not in sys.argv)
+
+    app = QGuiApplication(sys.argv)
+    app.setApplicationName("Steamify")
+    app.setDesktopFileName("steamify-ui")
+    icon = os.path.join(HERE, "..", "assets", "steam-gaming-settings.svg")
+    if os.path.isfile(icon):
+        app.setWindowIcon(QIcon(icon))
+
+    backend = Backend(script)
+    pad = Gamepad()
+    engine = QQmlApplicationEngine()
+    engine.setInitialProperties({"backend": backend, "gamepad": pad,
+                                 "fullscreen": fullscreen,
+                                 # Started from Steam: its keys are a Steam
+                                 # Controller's buttons (desktop layout).
+                                 "fromSteam": bool(os.environ.get("SteamGameId")),
+                                 "iconUrl": QUrl.fromLocalFile(os.path.realpath(icon)).toString()})
+    engine.load(os.path.join(HERE, "qml", "Main.qml"))
+    if not engine.rootObjects():
+        return 1
+    app.aboutToQuit.connect(backend.shutdown)
+    backend.refresh()
+    return app.exec()
+
+
+if __name__ == "__main__":
+    sys.exit(main())