feat(ci): VM tests on the Gitea mirror: boot loaders and all suites on this commit, from the newest Steamify ISO release

vmtest.yml (Gitea only) runs steamify-cachyos-dev's vmbootloadertest.sh per loader (limine, systemd-boot, grub), then the vmtest.sh suites on a plain VM from the same ISO, on pushes to main and release/**, pull requests and by hand.
2026-10-13 19:09:38 +02:00 · 2026-09-30 08:47:30 +02:00
39 changed files with 321 additions and 3017 deletions
@@ -192,18 +192,14 @@ jobs:
            dist/steamify-app.tar.gz
            assets/steam-gaming-settings.svg
-      # A new version starts the Steamify ISO's release of the ISO repo: its iso-1-github-tag.yml (always run from
+      # A new Steamify release starts the Steamify ISO's release with it (a test build from the ISO repo's
-      # master) names the ISO after the newest Steamify release, tags it, and the Gitea mirror builds and attaches the ISO.
+      # feat/steamify, until that is its master): its iso-release.yml names it after this version, tags it,
-      # The branch here decides the kind of build (the workflow's input `kind`):
+      # and the Gitea mirror builds and attaches the ISO. Needs a fine-grained token for that repo
-      #   main (publishes the release)            -> release: a real ISO (tag v<steamify>-<date>)
+      # (Actions: read and write) as the secret ISO_DISPATCH_TOKEN; without it, this is skipped.
      #   release/** (a version not yet released) -> dev: a pre-release (tag v<steamify>-dev.<date>)
      # Needs a fine-grained token for that repo (Actions: read and write) as the secret ISO_DISPATCH_TOKEN;
      # without it, this is skipped.
      - name: Start the Steamify ISO's release
        if: >-
          github.server_url == 'https://github.com' &&
-          github.event_name != 'pull_request' &&
+          github.event_name != 'pull_request' && github.ref == 'refs/heads/main' &&
          (github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/heads/release/')) &&
          steps.version.outputs.released == 'false'
        env:
          GH_TOKEN: ${{ secrets.ISO_DISPATCH_TOKEN }}
@@ -211,7 +207,5 @@ jobs:
          if [ -z "$GH_TOKEN" ]; then
            echo "::notice::No ISO_DISPATCH_TOKEN: the Steamify ISO isn't released with this version."; exit 0
          fi
-          # A release branch builds the ISO with its own code (and VERSION): steamify_ref. main builds the release it just published.
+          gh workflow run iso-release.yml -R theupriser/steammachine-cachyos-live-iso --ref feat/steamify
-          if [ "$GITHUB_REF" = refs/heads/main ]; then kind=release; sref=""; else kind=dev; sref="$GITHUB_REF_NAME"; fi
+          echo "Started the Steamify ISO's release (theupriser/steammachine-cachyos-live-iso, feat/steamify)"
          gh workflow run iso-1-github-tag.yml -R theupriser/steamify-cachyos-live-iso --ref master -f kind="$kind" -f steamify_ref="$sref"
          echo "Started the Steamify ISO's release (theupriser/steamify-cachyos-live-iso, master, kind $kind, Steamify ${sref:-the newest release})"
@@ -1,26 +0,0 @@
 name: Sync git.upriser.nl mirror
 # Trigger the Gitea pull-mirror immediately instead of waiting for its interval,
 # so Gitea builds/tests right after any branch or tag lands on GitHub (the mirror has no sync interval of its own).
 on:
  push:
    branches: ['**']
    tags: ['*']
  workflow_dispatch:
 jobs:
  sync:
    # Gitea also reads .github/workflows on the mirror; only run on GitHub
    if: github.server_url == 'https://github.com'
    runs-on: ubuntu-latest
    steps:
      - name: Trigger mirror-sync
        env:
          GITEA_URL: ${{ secrets.GIT_UPRISER_URL }}
          GIT_UPRISER_TOKEN: ${{ secrets.GIT_UPRISER_TOKEN }}
          # Gitea "owner/repo"; defaults to the same path as on GitHub
          GITEA_REPO: ${{ vars.GITEA_REPO || github.repository }}
        run: |
          curl --fail-with-body -sS --retry 5 --retry-delay 10 --retry-all-errors -X POST \
            -H "Authorization: token ${GIT_UPRISER_TOKEN}" \
            "${GITEA_URL%/}/api/v1/repos/${GITEA_REPO}/mirror-sync"
@@ -0,0 +1,209 @@
 # Steamify's own test run on the Gitea mirror (git.upriser.nl, its own runner; skipped on GitHub): the same as
 # `scripts/vmtest.sh` in steamify-cachyos-dev, on this commit's steamify.sh. The base is the newest Steamify ISO
 # release of the mirror (steamify-cachyos-live-iso): the boot loader tests (limine, systemd-boot, grub) install
 # it with this commit's Steamify, then the suites (cli, menu, hw, installer, toggles) run on a plain VM from
 # the same ISO (its Steamify step skipped: the suites start from a system without Steamify).
 # The runner needs /dev/kvm and privileged containers, about 12 GB of RAM for two VMs at a time (6 GB to
 # install, 4 GB to test, 2 vCPUs each).
 name: Steamify VM tests (Gitea)
 on:
  push:
    branches: [main, 'release/**']
  pull_request:
  workflow_dispatch:
 # A new run on the same branch or pull request stops the old one.
 concurrency:
  group: vmtest-${{ github.ref }}
  cancel-in-progress: true
 jobs:
  iso:
    name: Newest Steamify ISO
    if: github.server_url != 'https://github.com'
    runs-on: ubuntu-latest
    outputs:
      tag: ${{ steps.find.outputs.tag }}
      url: ${{ steps.find.outputs.url }}
    steps:
      - name: Find the newest ISO release on the mirror
        id: find
        run: |
          api="${{ github.server_url }}/api/v1/repos/theupriser/steamify-cachyos-live-iso/releases?limit=20"
          read -r tag url < <(curl -fsS "$api" | python3 -c '
          import json, sys
          for r in json.load(sys.stdin):
              for a in r["assets"]:
                  if a["name"].endswith(".iso"):
                      print(r["tag_name"], a["browser_download_url"]); raise SystemExit
          ')
          [ -n "$tag" ] || { echo "::error::no ISO release on the mirror"; exit 1; }
          echo "Using $tag"
          { echo "tag=$tag"; echo "url=$url"; } >> "$GITHUB_OUTPUT"
  boot:
    name: Boot loader ${{ matrix.loader }}
    needs: iso
    runs-on: ubuntu-latest
    timeout-minutes: 90
    container:
      image: docker.io/cachyos/cachyos:latest
      options: --privileged
    strategy:
      fail-fast: false
      max-parallel: 2
      matrix:
        loader: [limine, systemd-boot, grub]
    defaults:
      run:
        shell: bash
    steps:
      - name: Node and git
        id: node
        run: |
          pacman-key --init && pacman-key --populate
          pacman -Syu --noconfirm --needed nodejs git
          echo "week=$(date -u +%G-%V)" >> "$GITHUB_OUTPUT"
      - name: Cache - pacman packages
        uses: actions/cache@v4
        with:
          path: /var/cache/pacman/pkg
          key: pacman-test-${{ steps.node.outputs.week }}
          restore-keys: pacman-test-
      - name: Cache - the VMs' packages
        uses: actions/cache@v4
        with:
          path: /root/vms/pkg-cache
          key: vmpkg-steamify-${{ steps.node.outputs.week }}
          restore-keys: vmpkg-
      - name: Tools and KVM
        run: |
          pacman -S --noconfirm --needed qemu-desktop edk2-ovmf openssh libarchive procps-ng util-linux python curl sudo
          [ -c /dev/kvm ] || { echo "::error::no /dev/kvm in this container: the runner needs KVM (and privileged containers)"; exit 1; }
      - name: Cache - the ISO
        uses: actions/cache@v4
        with:
          path: iso
          key: steamify-iso-${{ needs.iso.outputs.tag }}
      # steamify-cachyos-dev (the scripts) and this commit of steamify-cachyos side by side (9p `repo` in the VMs).
      - uses: actions/checkout@v4
        with:
          path: steamify-cachyos
      - uses: actions/checkout@v4
        with:
          repository: theupriser/steamify-cachyos-dev
          path: steamify-cachyos-dev
      - name: ISO
        run: |
          mkdir -p iso
          [ -n "$(ls iso/*.iso 2>/dev/null)" ] || curl -fL --retry 5 --retry-all-errors -o "iso/${{ needs.iso.outputs.tag }}.iso" "${{ needs.iso.outputs.url }}"
      - name: Boot loader test (${{ matrix.loader }})
        env:
          CI: "1"
          VM_TIMEZONE: UTC
          VM_CPUS: "2"
          VM_INSTALL_MEM: 6G
        run: |
          mkdir -p ~/.ssh ~/vms/pkg-cache
          ssh-keygen -q -t ed25519 -N "" -C steamify-vm -f ~/.ssh/steamify-vm_ed25519
          cd steamify-cachyos-dev
          VM_ISO="$(ls "$GITHUB_WORKSPACE"/iso/*.iso | head -n 1)" scripts/vmbootloadertest.sh "${{ matrix.loader }}" --install
      - name: Logs
        if: always()
        uses: christopherhx/gitea-upload-artifact@v4
        with:
          name: boot-${{ matrix.loader }}
          path: |
            /root/vms/bl-${{ matrix.loader }}.test.log
            /root/vms/bl-${{ matrix.loader }}/vm.log
          retention-days: 7
          if-no-files-found: ignore
  suites:
    name: Suites (vmtest.sh)
    needs: [iso, boot]
    runs-on: ubuntu-latest
    timeout-minutes: 150
    container:
      image: docker.io/cachyos/cachyos:latest
      options: --privileged
    defaults:
      run:
        shell: bash
    steps:
      - name: Node and git
        id: node
        run: |
          pacman-key --init && pacman-key --populate
          pacman -Syu --noconfirm --needed nodejs git
          echo "week=$(date -u +%G-%V)" >> "$GITHUB_OUTPUT"
      - name: Cache - pacman packages
        uses: actions/cache@v4
        with:
          path: /var/cache/pacman/pkg
          key: pacman-test-${{ steps.node.outputs.week }}
          restore-keys: pacman-test-
      - name: Cache - the VMs' packages
        uses: actions/cache@v4
        with:
          path: /root/vms/pkg-cache
          key: vmpkg-steamify-${{ steps.node.outputs.week }}
          restore-keys: vmpkg-
      - name: Tools and KVM
        run: |
          pacman -S --noconfirm --needed qemu-desktop edk2-ovmf openssh libarchive procps-ng util-linux python curl sudo
          [ -c /dev/kvm ] || { echo "::error::no /dev/kvm in this container: the runner needs KVM (and privileged containers)"; exit 1; }
      - name: Cache - the ISO
        uses: actions/cache@v4
        with:
          path: iso
          key: steamify-iso-${{ needs.iso.outputs.tag }}
      # vmtest.sh wants the live-iso repository too (which boot loaders the ISO advertises).
      - uses: actions/checkout@v4
        with:
          path: steamify-cachyos
      - uses: actions/checkout@v4
        with:
          repository: theupriser/steamify-cachyos-dev
          path: steamify-cachyos-dev
      - uses: actions/checkout@v4
        with:
          repository: theupriser/steamify-cachyos-live-iso
          path: steamify-cachyos-live-iso
      - name: ISO
        run: |
          mkdir -p iso
          [ -n "$(ls iso/*.iso 2>/dev/null)" ] || curl -fL --retry 5 --retry-all-errors -o "iso/${{ needs.iso.outputs.tag }}.iso" "${{ needs.iso.outputs.url }}"
      - name: Base VM from the ISO
        env:
          CI: "1"
          VM_TIMEZONE: UTC
          VM_CPUS: "2"
          VM_INSTALL_MEM: 6G
          VM_STEAMIFY: skip
        run: |
          mkdir -p ~/.ssh ~/vms/pkg-cache
          ssh-keygen -q -t ed25519 -N "" -C steamify-vm -f ~/.ssh/steamify-vm_ed25519
          cd steamify-cachyos-dev
          VM_DIR="$HOME/vms/steamify-vm" scripts/vminstall.sh --iso "$(ls "$GITHUB_WORKSPACE"/iso/*.iso | head -n 1)"
      - name: vmtest.sh (every suite)
        env:
          CI: "1"
          VM_CPUS: "2"
          MAX_PARALLEL: "2"
        run: |
          cd steamify-cachyos-dev
          scripts/vmtest.sh cli menu hw installer toggles
      - name: Logs
        if: always()
        uses: christopherhx/gitea-upload-artifact@v4
        with:
          name: suites
          path: |
            /root/vms/last-test.txt
            /root/vms/run-*.log
          retention-days: 7
          if-no-files-found: ignore
@@ -1,2 +0,0 @@
 Not tested on hardware yet: the whole Steamify flow for the patched gamescope on NVIDIA (apply, reboot, session).
 Delete this file when it was, after asking the user (AGENTS.md).
@@ -48,19 +48,12 @@ 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`.
 - **NVIDIA** (`lib/nvidia.sh`): gamescope's session is broken on NVIDIA, so the SteamOS conversion (`gaming`, `boot`, `single`,
  `glyphs`) is hidden there (unless already on) and `nvidia` + its sub-option `bigpicture` ("Gaming on NVIDIA") replace it:
  Steam on the Plasma desktop, started at login. Never reintroduce a gamescope session for NVIDIA without re-testing on the
  hardware (notes: steamify-cachyos-dev, `nvidia/`). It can't be tested without the hardware: keep the branch behind
  `.no-release-yet` until it was.
 - **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"). New opt-in options (`NO_PRESELECT`) get the
+  (`feature_new`, shown as "new").
  same "new" badge without being ticked (`feature_new_optin`). Both count "Gaming
  on NVIDIA" as a parent where the conversion isn't offered.
  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
@@ -80,7 +73,7 @@ gamescope and the Plasma desktop. Primary target: the Valve Steam Machine
  `upload-artifact@v4` on GitHub and `christopherhx/gitea-upload-artifact@v4` elsewhere: never mention
  `upload-artifact@v3`, GitHub fails a workflow for a deprecated version even in a skipped step); the
  release is `gh` on GitHub and `akkuman/gitea-release-action` on Gitea. A new release on GitHub also starts the
-  Steamify ISO's release (`gh workflow run iso-1-github-tag.yml` in steamify-cachyos-live-iso, secret
+  Steamify ISO's release (`gh workflow run iso-release.yml` in steammachine-cachyos-live-iso, secret
  `ISO_DISPATCH_TOKEN`; skipped without it): the ISO repo's GitHub tag names it, the Gitea mirror builds it.
  CI (`.github/workflows/bundle.yml`) publishes the bundle as release
  `v$VERSION` on pushes to `main`; an existing version is never overwritten,
@@ -133,20 +126,7 @@ gamescope and the Plasma desktop. Primary target: the Valve Steam Machine
      `sudo apt install gh`, then `gh auth login`) instead of working around
      it. Only the
      release branch's pull request into `main` is the user's: never commit
-      or merge to `main`, the user merges that one. Never work directly on
+      or merge to `main`, the user merges that one.
      `main` or a `release/*` branch either: edits, even uncommitted ones,
      go on a `feature/`/`bugfix/` branch (create it before editing; the
      release branch only gets the version-bump commit and merged PRs).
      Don't push a new `release/*` branch before it's needed: a push can
      start CI builds (a dev ISO).
      A machine without a git identity: pass the repo's author per command
      (`git -c user.name=... -c user.email=... commit`, taken from `git
      log`) instead of changing the git config.
      A `.no-release-yet` file at the root of a feature/bugfix branch means
      it must not be merged into the release branch yet (work in progress,
      untested on hardware). When the feature is complete, ask the user
      whether it may be released; on a yes, delete the file, then open the
      pull request and merge it.
      Keep a feature/bugfix branch up to date by merging (or rebasing on)
      its release branch, the release branch by merging `main` when that
      moved.
@@ -156,12 +136,9 @@ gamescope and the Plasma desktop. Primary target: the Valve Steam Machine
    a warning when `VERSION` is a version that's already released (so a
    release branch that forgot its bump shows it on every PR).
  - A release that adds, removes or renames a menu row also retakes the
-    README screenshots (`assets/screenshot-menu-steam-machine.png` and
+    README screenshot (`assets/screenshot-menu.png`): the app from the
-    `assets/screenshot-menu-nvidia.png`, side by side in the README): the app from the branch on a Steam Machine and on a PC
+    branch on a Steam Machine, every row visible (window 1280 wide, tall
-    with an NVIDIA card, every row visible and each window only as tall as its options need, the header showing the new
+    enough), the header showing the new `VERSION`, scaled to 1600 px wide.
    `VERSION`, 1600 px wide. Size the window with a KWin script (match the `steamify-ui` class exactly: a title match also hits
    Konsole and editor windows) and crop the full-screen capture to the client rectangle; mind the display scale (the Steam
    Machine runs at 1.75).
  - 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),
@@ -331,7 +308,7 @@ gamescope and the Plasma desktop. Primary target: the Valve Steam Machine
  (`state_get vram installed_pkgs`).
 - Install-time mode (`steamify.sh --defaults`, 2.6.0): applies what the menu
  would preselect, no menu or prompts (needs passwordless sudo). The Steam
-  Machine ISO ([steamify-cachyos-live-iso](https://github.com/theupriser/steamify-cachyos-live-iso))
+  Machine ISO ([steammachine-cachyos-live-iso](https://github.com/theupriser/steammachine-cachyos-live-iso))
  runs it in the installer for a user who has never logged in: no session
  bus, user systemd or plasmashell. So every `systemctl --user` goes through
  `user_systemctl` (`lib/common.sh`; without a session only unit files change,
@@ -5,60 +5,6 @@ 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.11.2 - 2026-10-13
 - **fix: on an NVIDIA PC that had single user mode on before the SteamOS conversion, "Return to Gaming Mode" and the boot choice work again: single user mode's desktop autologin (`zzz-steamify-autologin.conf`, read last) pinned the Plasma session; the conversion removes it, and turning the conversion off sets it up again**
 - **fix: when an option fails, its sub-options are not applied any more (a failed conversion used to leave its "Boot into the desktop", silent start and icons on without it)**
 - **fix: a PC that keeps `python-hidapi` (liquidctl needs it) can use the SteamOS conversion: jupiter-hw-support, which gamescope-session-cachyos depends on, wants `python-hid`, which conflicts with it and stopped the package install. Steamify builds and installs an empty placeholder package that provides `python-hid` first (`patches/python-hid-shim.PKGBUILD`); only the Steam Deck controller firmware updater uses it**
 - **feat: the patched gamescope is downloaded as the newest release of steamify-gamescope-nvidia (checked against that release's `.sha256`), a newer one than the installed package shows the SteamOS conversion as an update, and what this Steamify was tested with is the fallback: the pinned package (sha256 in Steamify), the copy the ISO leaves, a build here; the repository's workflow builds each release in CachyOS's container**
 - `124b424`, `f234c72` **fix: HDMI-CEC on the Steam Machine no longer needs GitHub: when downloading Valve's CEC driver fails, Steamify uses the copy it carries (`patches/cros-ec-cec.c`), checked against the same pinned sha256**
 - `127b8cf`, `2811ecc`, `f3cd053`, `4325d80`, `03f9e87`, `5b5181f`, `06ffc8b`, `4d60dd2`, `0ba94b2` **feat: the SteamOS conversion is offered on NVIDIA PCs again (GTX 16 / RTX 20 series or newer: Turing and later, the cards NVIDIA's open kernel driver supports): it builds and installs a patched gamescope from the recipe and patch Steamify carries (`patches/`, prepared in [steamify-gamescope-nvidia](https://github.com/theupriser/steamify-gamescope-nvidia); gamescope 3.16.31, so a Steamify release builds the version it was tested with) (GBM-allocated scan-out buffers, NVIDIA's corrupted gaming-mode picture, gamescope#2309; a few minutes to build) and sets `gamescope_drm_gbm_scanout=1` for the session (`lib/gamescope-nvidia.sh`). It replaces "Gaming on NVIDIA", which is not offered any more (the kernel parameters, early modules, suspend memory and the 32-bit libraries come with the conversion on a supported card; a PC that had "Gaming on NVIDIA" on has it turned off when the conversion is turned on). Tested on an RTX 5080 (driver 615.78.08): Steam's gaming UI is clean with it and shows artifacts without. The package is pinned to one gamescope release: updating it is not automatic yet**
 - `ce4bc67` **feat: "Gaming on NVIDIA" also keeps video memory over suspend (`NVreg_PreserveVideoMemoryAllocations=1` in `/etc/modprobe.d/90-steamify-nvidia.conf`, the initramfs is rebuilt), enables `nvidia-suspend`/`nvidia-resume`/`nvidia-hibernate`, and installs `lib32-nvidia-utils` and `lib32-libxkbcommon` (32-bit games, the 32-bit MangoHud preload) on a supported card; off removes only what Steamify added. Untested on hardware yet**
 ## 2.11.1 - 2026-10-02
 - `d70aeb8` **docs: new README screenshots of the app (2.11 menu) on a Steam Machine and on an NVIDIA PC, and the README names the opt-in "Start Steam silently in desktop mode" and the icons as an option of the conversion**
 ## 2.11.0 - 2026-10-01
 - `2e51d1d`, `3494924`, `fbdad5a`, `079e725`, `188799e` **feat: "Start Steam silently" sub-option: under the SteamOS conversion (`silent`, opt-in now: it was always on before; an existing one is moved from its systemd unit to the autostart entry by the "update") and under Gaming on NVIDIA (`nvsilent`, opt-in, not together with Big Picture); the SteamOS one is called "Start Steam silently in desktop mode" and is always shown, also on a Steam Machine; it is Steam's own autostart entry (`~/.config/autostart/steam.desktop`), so Steam's setting "Run Steam when my computer starts" follows it**
 - `2f7b53f` **fix: the Steam Machine's serial number step no longer fails inside the ISO's installer (`/sys` is read-only in its chroot; the tmpfiles.d file applies at the next boot anyway), which made `machine` report an error and the install log end with `exit: 1`**
 - `45a23af`, `bd8f387` **feat: `STEAMIFY_NO_DOWNLOAD` (the ISO's `steamify.nodownload` kernel parameter): the installed system's first login runs the Steamify bundle of the ISO instead of downloading the newest release (to test an unreleased Steamify)**
 - `f3810a9` **fix: the SteamOS theme no longer leaves a blank Discover pin in the taskbar (Plasma's default taskbar pins Discover, which CachyOS doesn't install); the taskbar gets CachyOS's own pins (System Settings, files, browser), also on the ISO's first login**
 - `7869b47` **feat: "Steam Deck/Machine icons" (`glyphs`) is a sub-option of the SteamOS conversion, like "Start Steam silently in desktop mode": it only changes gaming mode**
 - `4d387b2` **chore: the Steamify unit tests (`controllers-test.sh`, `nvidia-test.sh`) and the NVIDIA hardware test live in steamify-cachyos-dev (`tests/`) now; `tests/` is removed here**
 ## 2.10.0 - 2026-10-01
 - `d6db4f6` **feat: "Gaming on NVIDIA" (nvidia) replaces the SteamOS conversion on PCs with an NVIDIA GPU, where gamescope's gaming mode shows a corrupted picture (NVIDIA bug 5240452): Steam is installed when missing and starts at login on the Plasma desktop; the sub-option "Steam starts in Big Picture" (bigpicture) starts it in Big Picture, unticked in its normal window, on an empty Plasma session so windows of the last session don't cover it. On a supported card (RTX 20 series or newer) it also sets the NVIDIA kernel parameters and early modules. The conversion and its options are hidden there unless already on**
 - `d1373e2` **feat: single user mode also works on NVIDIA PCs, without the SteamOS conversion**
 - `5811f5c` **fix: "Add as non-Steam game" isn't offered on NVIDIA PCs (shown when already on, so it can be turned off)**
 - `83248a8` **feat: Extended controller support (extended_controller_support, off by default): the Xbox wireless dongle (xone) and Xbox controllers over Bluetooth with rumble and battery level (xpadneo), built for every installed kernel; off removes only what Steamify installed**
 - `01a77b7` **feat: a new opt-in option (unticked by default) shows the "new" badge in the menu and the app**
 - `f1983a9` **docs: README screenshots of the 2.10.0 app, side by side: on a Steam Machine and on a PC with an NVIDIA card**
 ## 2.9.6 - 2026-09-30
 - **fix(ci): a dev ISO from a release branch is built with that branch's own Steamify (input steamify_ref of the ISO workflow), not the newest published release: release/2.9.6 kept producing 2.9.5 ISOs**
 - **docs: changelog hashes for 2.9.6**
 - `9a2965d` **fix(ci): the ISO workflow always runs from master; main asks for a release ISO, a release branch for a dev ISO (input `kind` of iso-1-github-tag.yml; feat/steamify is no longer needed)**
 - `c42d545` **fix(ci): a version published from main starts a real ISO release, a release branch a dev ISO (it always started the dev one)**
 - `b3bed43` **chore: Version 2.9.6**
 ## 2.9.5 - 2026-09-30
 - `70ecb56` **ci: trigger a mirror sync**
 - `a7276cf` **ci: sync the git.upriser.nl mirror on every branch and tag**
 - `b3549d4` **ci: sync the mirror on release branch pushes too**
 - `a232a55` **feat(ci): sync the git.upriser.nl mirror on every push to main and every tag (git-upriser-sync.yml calls the mirror-sync API: the Gitea mirror builds at once instead of at its interval; secrets GIT_UPRISER_URL and GIT_UPRISER_TOKEN, retried, skipped on Gitea itself)**
 - `3676c64` **docs: link the renamed steamify-cachyos-live-iso repo (the release dispatches the ISO workflow iso-1-github-tag.yml there)**
 - `971e792` **chore: Version 2.9.5**
 ## 2.9.4 - 2026-09-29
 - `619ef1f` **docs: AGENTS.md and TECHNICAL.md: the CEC driver cache, the one workflow for GitHub and a Gitea mirror, and that a new release starts the Steamify ISO's release**
@@ -1,14 +1,6 @@
 # Steamify CachyOS
-The Steamify app's menu. On a Steam Machine (or any PC with an AMD or Intel
+![The Steamify app's menu on a Steam Machine](assets/screenshot-menu.png)
 graphics card) it offers the full SteamOS conversion, on the left. On a PC with
 an NVIDIA graphics card gamescope's gaming mode shows a corrupted picture, so the
 menu offers **Gaming on NVIDIA** instead (Steam on the desktop, started at login,
 optionally in Big Picture), on the right.
 | On a Steam Machine | On a PC with an NVIDIA graphics card |
 |---|---|
 | ![The Steamify app's menu on a Steam Machine](assets/screenshot-menu-steam-machine.png) | ![The Steamify app's menu on a PC with an NVIDIA graphics card](assets/screenshot-menu-nvidia.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
@@ -27,24 +19,14 @@ Steam Machine.
   on the desktop too.
   - **Boot into: gamescope / desktop** - where the PC starts. Gaming mode is
     the default.
   - **Start Steam silently in desktop mode** (off by default) - Steam starts
     at login on the desktop, in the tray without a window. It is Steam's own
     autostart entry, so Steam's setting "Run Steam when my computer starts"
     follows it (the Linux Steam client has no silent option of its own).
   - Steam's **System** settings show the SteamOS release Steamify follows
     as OS Version (e.g. `steamos-3.9`), `steam-machine` as OS Codename and
     Steamify's version as OS Variant. The OS name stays CachyOS
     ([details](TECHNICAL.md#what-steams-system-settings-show)).
   - **NVIDIA graphics cards:** gamescope's gaming mode shows a corrupted
     picture there (an open NVIDIA driver bug), so the conversion isn't
     offered. **Gaming on NVIDIA** takes its place: Steam on the desktop,
     installed if it's missing and started at login, in **Big Picture** or its
     normal window as you choose
     ([details](TECHNICAL.md#gaming-on-nvidia)).
 2. **SteamOS theme** - the Vapor look of SteamOS for the desktop, with
   **Add to Steam** in right-click menus
   ([details](TECHNICAL.md#steamos-desktop-look)).
-3. **Steam Deck/Machine icons** - Steam Deck button icons in gaming mode (an option of the SteamOS conversion).
+3. **Steam Deck/Machine icons** - Steam Deck button icons in gaming mode.
 4. **Single user mode** - like SteamOS: never a login or lock screen, and no
   KDE wallet password prompts (e.g. from Brave). Typing a password with a
   controller is no fun
@@ -55,7 +37,7 @@ Steam Machine.
   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. Not offered on PCs with an NVIDIA graphics card, which have no gaming mode.
+   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
@@ -74,11 +56,6 @@ Steam Machine.
   the Steam Machine) or a USB CEC adapter; most graphics cards, NVIDIA
   included, don't have it. See [CEC.md](CEC.md) for which PCs do, and how to
   add it to your own build ([details](TECHNICAL.md#hdmi-cec)).
 9. **Extended controller support** (off by default) - the Xbox wireless
   dongle (xone) and Xbox controllers over Bluetooth with rumble, the right
   button mapping and the battery level (xpadneo). Both are installed from the
   CachyOS repo and built for every installed kernel
   ([details](TECHNICAL.md#extended-controller-support)).
 ## Steam Machine
@@ -117,7 +94,7 @@ curl -fsSL https://github.com/theupriser/steamify-cachyos/releases/latest/downlo
 ```
 Installing CachyOS on a Steam Machine? The
-[Steamify CachyOS ISO](https://github.com/theupriser/steamify-cachyos-live-iso)
+[Steamify CachyOS ISO](https://github.com/theupriser/steammachine-cachyos-live-iso)
 has Steamify built into the installer: pick the options there, and the
 first boot is already set up.
@@ -187,16 +164,6 @@ Contributing (or an AI agent)? Read [AGENTS.md](AGENTS.md).
 MIT - do whatever you want with it. See [LICENSE.md](LICENSE.md).
 ### Code from other projects
 Some files in `patches/` are not MIT. They keep their own license, and each file says where it comes from:
 | File | What | License and source |
 |---|---|---|
 | `steamify-fremont-poweroff.c` | Kernel module for the Steam Machine's power-off fix. It does what Valve's Steam Machine kernel does for this (clears the S4 wake bit of GPIO pin 18 at probe), but at power-off, for kernels without Valve's change. Valve's kernel: [evlaV/linux-integration](https://github.com/evlaV/linux-integration). | GPL-2.0, like the Linux kernel it is built into |
 | `cros-ec-cec.c` | Valve's Steam Machine HDMI-CEC driver (ChromeOS EC CEC, Copyright BayLibre; Valve's version of it), at a pinned commit of [evlaV/linux-integration](https://github.com/evlaV/linux-integration). Used when it can't be downloaded. | GPL-2.0+, unmodified (Steamify's `cros-ec-cec-single-port.patch` is applied when it is built) |
 | `gamescope-gbm-scanout.patch` | GBM scan-out for gamescope on NVIDIA: nine commits of [farnoy/gamescope](https://github.com/farnoy/gamescope) on [ValveSoftware/gamescope](https://github.com/ValveSoftware/gamescope). | gamescope's license (BSD-2-Clause) |
 ## Disclaimer
 Steamify CachyOS is an unofficial community project. It is not affiliated
@@ -43,14 +43,6 @@ user wallet, with anything saved in it meanwhile, is kept as
 `kdewallet.kwl.steamify-single-user` and used again the next time it's on.
 Passwords aren't shared between the two wallets.
 **Without the conversion (NVIDIA PCs, where gamescope's session is broken)** nothing else logs in by itself, so single user mode
 does that too: `single_login_enable` (`lib/single-user.sh`) switches to SDDM and writes
 `/etc/sddm.conf.d/zzz-steamify-autologin.conf` (`User=`, `Session=plasma.desktop`, `Relogin=true`; named to sort after
 `steam-set-session`'s `zz-steamos-autologin.conf`, which may still say gamescope from an earlier conversion), and drops any
 `[Autologin]` from `/etc/sddm.conf`. Turning it off removes the file and goes back to plasma-login-manager. With the
 conversion on, the conversion does the login as before. Ticking single user mode only ticks the conversion where the
 conversion is offered.
 **SDDM** is what SteamOS uses, and CachyOS's `steam-set-session` supports it
 directly: it writes `/etc/sddm.conf.d/zz-steamos-autologin.conf`, which SDDM
 honours. The script installs and enables `sddm` (active from the next boot),
@@ -108,11 +100,9 @@ tools write to the conf.d fragment into the base config.
  (never `zz-steamos-autologin.conf`, which CachyOS's tools own), and
  installs `/usr/local/bin/sync-steamos-session.sh` plus
  `sync-steamos-session.path`/`.service`;
- `KWIN_IM_SHOW_ALWAYS=1` for the virtual keyboard; the sub-option `silent`
+- `KWIN_IM_SHOW_ALWAYS=1` for the virtual keyboard and a
-  ("Start Steam silently in desktop mode", opt-in, always shown) writes
+  `steam-desktop-autostart` systemd user service that starts Steam silently
-  `~/.config/autostart/steam.desktop` (the system steam.desktop with `-silent` in its Exec line). That is the
+  in Plasma only;
  file Steam's own setting "Run Steam when my computer starts" creates and removes, so the setting shows it. An older
  `steam-desktop-autostart` user unit is removed;
 - the **Return to Gaming Mode** shortcut; on plasma-login-manager with a
  narrow sudoers rule (`/etc/sudoers.d/gamescope-session-switch`) so it can
  restart the login manager without a password prompt.
@@ -126,8 +116,7 @@ The conversion also sets what Steam's System settings show, see
 **Steam Deck/Machine icons:** `STEAM_GAMEPADUI_ARGS="-gamepadui -steamos3"`
 in `~/.config/environment.d/` (and gamescope-session's own environment
-file), which makes Steam show Steam Deck button glyphs in gaming mode. It is a sub-option of the SteamOS conversion (`gaming`):
+file), which makes Steam show Steam Deck button glyphs in gaming mode.
 it does nothing without gaming mode, ticking it ticks the conversion and turning the conversion off turns it off.
 ## SteamOS desktop look
@@ -217,74 +206,6 @@ or upgraded. A newly added kernel doesn't come with its headers, so
 `ensure-kernel-headers.service` checks at every boot and installs any
 missing `-headers` package, which makes DKMS build the driver for it.
 ## Extended controller support
 `extended_controller_support` (`lib/controllers.sh`, top-level, off by default, 2.10.0) installs two kernel drivers from CachyOS's own
 repo (no AUR): `xone-dkms` with `xone-dongle-firmware` for the Xbox wireless dongle (the kernel has no driver for it; wired
 Xbox controllers go through the same driver), and `xpadneo-dkms` for Xbox One/Series controllers over Bluetooth (without it
 they work as plain gamepads but miss rumble including the triggers, the right button mapping and the battery level). Both are
 DKMS modules, built for every installed kernel, so `install_kernel_headers` (`lib/steam-machine.sh`) makes sure each kernel has its
 headers first. A PC that already has the AUR's `xone-dkms-git` keeps it: it provides the same driver and conflicts with the repo's
 `xone-dkms`. Status is the three packages being installed. Off removes only what Steamify installed (state
 `extended_controller_support`, `installed_pkgs`); the headers stay. The drivers load when the device shows up: the dongle is
 plugged in again, or the controller reconnected. Its test is in steamify-cachyos-dev (`tests/controllers-test.sh`).
 ## Gaming on NVIDIA
 gamescope's own gaming mode shows a corrupted picture on NVIDIA graphics cards: NVIDIA's open bug 5240452 (flicker and
 artifacts in the DRM session at modes above 2560x1440@120, seen up to driver 595 and on RTX 3070 Ti, 4090, 5090 and 5080;
 no fix known). The kernel parameters `nvidia-drm.modeset=1`/`fbdev=1` and loading the NVIDIA modules early don't change it
 (the driver already reports both `Y`), and gamescope started nested inside KDE artifacts too when KWin hands its fullscreen
 window straight to the display. What does work on an RTX 5080: Steam's Big Picture (`steam -gamepadui`) as a normal window of
 the Plasma desktop session, smooth and clean.
 Since 2.11.2 there is a second way: gamescope with GBM-allocated scan-out buffers (`lib/gamescope-nvidia.sh`). On an RTX 5080
 (driver 615.78.08, 3440x1440@175) Steam's gaming UI in gamescope's DRM session is clean with it and shows artifacts everywhere
 without. The patch is nine commits of [farnoy/gamescope](https://github.com/farnoy/gamescope) (`nvidia-gbm-wayland`), carried in
 `patches/` (`gamescope-gbm-scanout.patch` and the recipe `gamescope-nvidia.PKGBUILD`, kept in sync with
 [steamify-gamescope-nvidia](https://github.com/theupriser/steamify-gamescope-nvidia), where new gamescope versions are
 prepared). gamescope changes every few weeks, so the package is downloaded, not carried: `gsn_install_package` takes the
 **newest release** of that repository (CI builds it in CachyOS's container; a person merges the version bump), checked against the
 `.sha256` of the same release, and installs it with `pacman -U --ask 4` (the package provides and conflicts with `gamescope`). What
 this Steamify release was tested with is the fallback, in this order: the pinned package (`GSN_VERSION`, `GSN_SHA256`: from GitHub, the
 cache, or the copy the ISO leaves in `/usr/local/share/steamify/gamescope`), then a build here from the recipe and patch in `patches/`
 (`makepkg -sf` as the user, in `~/.cache/steamify`; no checksums on gamescope's own sources). A package that downloaded fine but
 doesn't install goes on to the next step; nothing changes before one of them is installed. A newer release than the installed package
 shows the conversion as an update (`gsn_update_pending`, looked up at most every six hours, quiet offline). Simple files that don't
 change (the power-off module, small patches) stay in `patches/` as they are. It is opt-in inside gamescope: `gamescope_drm_gbm_scanout=1` in
 `~/.config/gamescope-session/environment` and `~/.config/environment.d/99-steamify-gamescope-nvidia.conf`. The SteamOS conversion
 (`gaming_enable`) does this on every NVIDIA PC (`nvidia_present`: PCI vendor 0x10de, display class, its driver providing
 `nvidia_drm`), together with what "Gaming on NVIDIA" set up (on a supported card, `nvidia_supported`: GTX 16 / RTX 20 series or
 newer, Turing and later): the kernel parameters, the early modules, suspend memory, the 32-bit libraries (`nvidia_kernel_enable`,
 `nvidia_extras_enable`). So the SteamOS conversion is the one gaming option on NVIDIA now, and "Gaming on NVIDIA" (below) is not
 offered any more (`nvidia_available`); a PC that had it on keeps it until the conversion is turned on, which turns it off
 (`nvidia_swap_out`). Turning the conversion off removes the setting and those settings, and keeps the packages. Tested on an RTX 5080 only.
 Before 2.11.2, with an NVIDIA GPU the SteamOS conversion (`gaming`, and its options `boot`, `single`, `glyphs`) wasn't offered, unless
 it was already on. `nvidia` ("Gaming on NVIDIA", `lib/nvidia.sh`) took its place (both would start Steam at login): it installs `steam` when missing (recorded in state `nvidia`, removed again only then) and enables the user
 unit `steamify-steam-autostart.service` (`services/`, `ExecStart=/usr/bin/steam @ARGS@`, Plasma only). Its sub-option
 `bigpicture` ("Steam starts in Big Picture", ticked along with it) rewrites the unit with `-gamepadui` and sets
 `ksmserverrc [General] loginMode=emptySession` (`kset`, undone with `krevert bigpicture`), so windows of the last session
 (Discord, a browser) aren't restored on top of Big Picture; unticked, Steam starts in its normal window. The opt-in sub-option `nvsilent` ("Start Steam silently") rewrites the unit with `-silent`
 (tray only); it and `bigpicture` exclude each other. The PC always boots into the desktop: there is no gamescope session. Takes effect at the next
 login.
 On a supported card (RTX 20 series or newer: not on chwd's legacy lists `/var/lib/chwd/ids/nvidia-*.ids`, the VRAM booster's
 check, `vram_nvidia_legacy_id`; `nvidia_supported`) enabling it also does what NVIDIA's DRM stack wants, though it didn't cure
 gamescope: `nvidia-drm.modeset=1 nvidia-drm.fbdev=1` on the kernel command line (Limine, systemd-boot or GRUB; the file is
 backed up first; on Limine into the existing `KERNEL_CMDLINE[default]="..."` or `+="..."` line, never an extra appended line,
 which ends up as text; the kernel treats `nvidia_drm` and `nvidia-drm` alike) and
 `/etc/mkinitcpio.conf.d/90-steamify-nvidia.conf` (`MODULES+=(nvidia nvidia_modeset nvidia_uvm nvidia_drm)`), then the initramfs
 and boot entries are rebuilt and checked for the parameters. The early-load drop-in is only there while every installed kernel
 has the NVIDIA modules (mkinitcpio fails on a missing module, and `limine-mkinitcpio` then skips that kernel's boot entry):
 a pacman hook (`/etc/pacman.d/hooks/85-steamify-nvidia-initramfs.hook`, after DKMS, before the initramfs is built) runs
 `/usr/local/libexec/steamify-nvidia-initramfs` at every kernel or driver change and decides again. Turning it off removes
 all of it. The tests are in steamify-cachyos-dev: `tests/nvidia-test.sh` (a fake GPU, a stub `pacman` and `systemctl`, a temp home) and `tests/nvidia-hardware-test.sh` (a real NVIDIA PC).
 Tried and dropped (notes in steamify-cachyos-dev, `nvidia/HARDWARE-RESULTS.md`): a gamescope session that opens Big Picture in Plasma (it needed the `start-gamescope-session`
 command shadowed in `/usr/local/bin`, and showed the desktop for a few seconds, then a Steam window with a black border);
 a KWin session without Plasma (the mouse stuttered every second or two).
 ## HDMI-CEC
 The **HDMI-CEC** item (on every PC; ticked by default only on a Steam
@@ -367,7 +288,8 @@ 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 (`steam -silent`). That's refused in gaming
+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
@@ -512,8 +434,7 @@ In the home folder, everything is under `steamify`:
 | `~/.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/autostart/steam.desktop` | the `silent` option (Steam's "Run Steam when my computer starts") |
+| `~/.config/systemd/user/` | `steamify-update-check.*`, `steam-desktop-autostart.service` |
 | `~/.config/systemd/user/` | `steamify-update-check.*` |
 System-wide: `/usr/local/lib/steamify/` (kernel headers script),
 `/usr/src/steamify-*` (DKMS modules), `/var/cache/steamify/kernel` (the old
@@ -559,9 +480,7 @@ steamify.sh --defaults --list                           # what --defaults can se
 item this PC can't use (e.g. `vram` without a VRAM region) is left off with
 a warning. `--boot desktop` needs `gaming`. Unknown options, ids, `boot` or
 `bios` in the list: exit code 1 before anything changes. What needs a
-Plasma session waits for the first login (`lib/first-login.sh`). The same step (and the online theme path) replaces Plasma's default taskbar pins, which include Discover
+Plasma session waits for the first login (`lib/first-login.sh`).
 (not installed on CachyOS: a blank icon), by CachyOS's own (`taskbar_drop_discover` in `lib/vapor-theme.sh`; skipped when Discover is
 installed or the taskbar already has its own `launchers`).
 With `Relogin=true`, a gamescope session that fails to start is restarted
 immediately, which can turn into a loop - see
@@ -591,9 +510,6 @@ immediately, which can turn into a loop - see
 | `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/first-login.sh` | `--defaults` without a session (the Steam Machine ISO's installer): the one-time first-login step that sets up single user's launcher on Plasma's new layout and opens the app |
 | `lib/controllers.sh` | Extended controller support: Xbox wireless dongle (xone) and Xbox Bluetooth (xpadneo) from the CachyOS repo |
 | `lib/gamescope-nvidia.sh` | gamescope on NVIDIA: builds and installs the patched gamescope (GBM scan-out) from steamify-gamescope-nvidia and sets `gamescope_drm_gbm_scanout=1` for the SteamOS conversion |
 | `lib/nvidia.sh` | Gaming on NVIDIA: Steam on the desktop, started at login, optionally in Big Picture (replaces the SteamOS conversion there) |
 | `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 |
@@ -50,11 +50,10 @@ backend_status() {
        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+=",\"needs\":\"\""
        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" || feature_new_optin "$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:-}" ]] &&
@@ -147,18 +146,8 @@ backend_apply() {
        for id in "${want[@]}"; do [[ "$id" == "$c" ]] && WANTED[$c]=1; done
    done
    # The same rules as the menu's toggles.
-    [[ "${WANTED[single]:-0}" == 1 ]] && component_available gaming && WANTED[gaming]=1
+    [[ "${WANTED[single]:-0}" == 1 ]] && WANTED[gaming]=1
-    if component_available gaming; then
+    [[ "${WANTED[gaming]:-0}" == 0 ]] && { WANTED[single]=0; WANTED[boot]=0; }
        [[ "${WANTED[gaming]:-0}" == 0 ]] && { WANTED[single]=0; WANTED[boot]=0; }
    else
        WANTED[boot]=0
    fi
    [[ "${WANTED[bigpicture]:-0}" == 1 ]] && WANTED[nvidia]=1
    [[ "${WANTED[nvsilent]:-0}" == 1 ]] && WANTED[nvidia]=1
    [[ "${WANTED[bigpicture]:-0}" == 1 ]] && WANTED[nvsilent]=0
    [[ "${WANTED[nvidia]:-0}" == 0 ]] && { WANTED[bigpicture]=0; WANTED[nvsilent]=0; }
    [[ "${WANTED[silent]:-0}" == 1 || "${WANTED[glyphs]:-0}" == 1 ]] && component_available gaming && WANTED[gaming]=1
    [[ "${WANTED[gaming]:-0}" == 0 ]] && { WANTED[silent]=0; WANTED[glyphs]=0; }
    [[ "${WANTED[poweroff]:-0}" == 1 ]] && WANTED[machine]=1
    [[ "${WANTED[machine]:-0}" == 0 ]] && WANTED[poweroff]=0
    [[ "${WANTED[kpin]:-0}" == 1 ]] && WANTED[machine]=1
@@ -185,12 +174,6 @@ backend_apply() {
        if backend_run_component "$c" disable; then feature_record "$c" disable; else failed+=("$c"); fi
    done
    for c in "${TO_ENABLE[@]}"; do
        # A sub-option of something that just failed isn't applied: it would be left on without its parent.
        if [[ -n "${PARENT[$c]:-}" && " ${failed[*]:-} " == *" ${PARENT[$c]} "* ]]; then
            backend_event log "\"id\":$(json_str "$c"),\"line\":$(json_str "Skipped: ${LABEL[${PARENT[$c]}]%%:*} didn't work.")"
            failed+=("$c")
            continue
        fi
        if backend_run_component "$c" enable; then is_action "$c" || feature_record "$c" enable; else failed+=("$c"); fi
    done
    feature_record_unticked
@@ -73,16 +73,11 @@ cec_driver_enable() {
        cp "$CEC_DRIVER_CACHE" "$tmp/cros-ec-cec.c"
    else
        info "Downloading Valve's Steam Machine CEC driver..."
-        if ! curl -fsL --retry 2 --max-time 60 "$CEC_DRIVER_URL" -o "$tmp/cros-ec-cec.c" ||
+        if ! curl -fsL --retry 2 "$CEC_DRIVER_URL" -o "$tmp/cros-ec-cec.c" ||
            ! echo "$CEC_DRIVER_SHA256  $tmp/cros-ec-cec.c" | sha256sum -c --quiet -; then
-            # GitHub is down, rate-limits us, or sent something else: Steamify carries the same file (checked the same way).
+            rm -rf "$tmp"
-            warn "Downloading Valve's CEC driver failed (or its checksum didn't match): using the copy Steamify carries."
+            err "Downloading Valve's CEC driver failed (or its checksum didn't match)."
-            patch_file cros-ec-cec.c > "$tmp/cros-ec-cec.c"
+            return 1
            if ! echo "$CEC_DRIVER_SHA256  $tmp/cros-ec-cec.c" | sha256sum -c --quiet -; then
                rm -rf "$tmp"
                err "Steamify's own copy of Valve's CEC driver doesn't match the pinned checksum (a new pin needs a new copy in patches/)."
                return 1
            fi
        fi
        # The name carries the checksum: a newer pin gets its own file, the old one goes.
        sudo find "${CEC_DRIVER_CACHE%/*}" -maxdepth 1 -name 'cros-ec-cec-*.c' ! -name "${CEC_DRIVER_CACHE##*/}" -delete 2>/dev/null
@@ -1,43 +0,0 @@
 #!/bin/bash
 # Extended controller support: the Xbox wireless dongle (xone, with its firmware) and Xbox controllers over Bluetooth (xpadneo).
 # The kernel has no driver for the dongle, and without xpadneo a Bluetooth Xbox controller works as a plain gamepad (buttons and
 # sticks) but misses rumble (trigger motors too), proper button mapping and the battery level. Both are DKMS modules from CachyOS's
 # own repo, built for every installed kernel (so every kernel needs its headers). Sourced by steamify.sh; not meant to be run on
 # its own.
 controller_xone_pkg() {
    # A PC with the AUR's xone-dkms-git already works: the repo's xone-dkms would conflict with it.
    pacman -Q xone-dkms-git >/dev/null 2>&1 && echo xone-dkms-git || echo xone-dkms
 }
 controller_pkgs() { echo "xpadneo-dkms $(controller_xone_pkg) xone-dongle-firmware"; }
 extended_controller_support_status() {
    # shellcheck disable=SC2046 # a list of package names
    pacman -Q $(controller_pkgs) >/dev/null 2>&1
 }
 extended_controller_support_enable() {
    local p prev missing=()
    info "Installing extended controller support (Xbox wireless dongle, Xbox Bluetooth)..."
    install_kernel_headers || return 1
    for p in $(controller_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; }
        # What a first, half-finished run installed stays on the list.
        prev="$(state_get extended_controller_support installed_pkgs)"
        state_set extended_controller_support installed_pkgs "$(echo "$prev ${missing[*]}" | xargs)"
    fi
    ok "Extended controller support on: plug the dongle in again (or reconnect the controller) to use it."
 }
 extended_controller_support_disable() {
    local pkgs
    pkgs="$(state_get extended_controller_support installed_pkgs)"
    # Only what Steamify installed; kernel headers stay.
    # shellcheck disable=SC2086 # a list of package names
    [[ -n "$pkgs" ]] && sudo pacman -Rns --noconfirm $pkgs >/dev/null 2>&1
    state_clear extended_controller_support
    ok "Extended controller support off."
 }
@@ -7,25 +7,13 @@
 FIRST_LOGIN_ENTRY="${XDG_CONFIG_HOME:-$HOME/.config}/autostart/steamify-first-login.desktop"
 FIRST_LOGIN_SCRIPT="$STEAMIFY_BIN/first-login"
 FIRST_LOGIN_BUNDLE="$STEAMIFY_BIN/first-login-steamify.sh"
 first_login_schedule() {
    # The newest release's Steamify runs at the first login. STEAMIFY_NO_DOWNLOAD (the ISO was started with
    # steamify.nodownload, to test an unreleased Steamify): this very bundle runs instead.
    # (Only a single-file bundle can be copied; SCRIPT_DIR doesn't exist in one.)
    local run self="${BASH_SOURCE[0]:-}"
    if [[ -n "${STEAMIFY_NO_DOWNLOAD:-}" && -f "$self" ]] && grep -q '^# Single-file build' "$self"; then
        install_executable "$FIRST_LOGIN_BUNDLE" 755 < "$self"
        run="bash \"$FIRST_LOGIN_BUNDLE\" --first-login; rm -f \"$FIRST_LOGIN_BUNDLE\""
    else
        run="curl -fsSL --max-time 30 \"$WIZARD_URL\" | bash -s -- --first-login"
    fi
    install_executable "$FIRST_LOGIN_SCRIPT" 755 << EOF2
 #!/bin/bash
 # Installed by Steamify CachyOS: runs once, at the first desktop login.
 set -o pipefail
-mkdir -p ~/.cache
+curl -fsSL --max-time 30 "$WIZARD_URL" | bash -s -- --first-login
 { $run; } > ~/.cache/steamify-first-login.log 2>&1
 rm -f "$FIRST_LOGIN_ENTRY" "\$0"
 [[ -x "$WIZARD_APP_LAUNCHER" ]] && exec "$WIZARD_APP_LAUNCHER"
 EOF2
@@ -43,9 +31,10 @@ first_login_run() {
        [[ -n "$(plasma_applets org.kde.plasma.kickoff)" ]] && break
        sleep 2
    done
-    stop_plasmashell_for_edit
+    if single_status; then
-    taskbar_drop_discover
+        stop_plasmashell_for_edit
-    single_status && single_launcher
+        single_launcher
-    restart_plasmashell_if_stopped
+        restart_plasmashell_if_stopped
    fi
    return 0
 }
@@ -1,204 +0,0 @@
 #!/bin/bash
 # gamescope's own gaming mode on NVIDIA: a patched gamescope that allocates its scan-out buffers with GBM, which cures
 # the corrupted picture (https://github.com/ValveSoftware/gamescope/issues/2309). The patch is opt-in: gamescope reads
 # `gamescope_drm_gbm_scanout=1` from its environment, which is set for the gaming session (gamescope-session's
 # environment file, and environment.d).
 #
 # gamescope changes every few weeks, so the package is not carried but downloaded: the newest release of
 # https://github.com/theupriser/steamify-gamescope-nvidia (CI builds it in CachyOS's container, a person merges the
 # version bump), and a newer one than the installed package shows as an update of the SteamOS conversion
 # (`gsn_update_pending`). What this Steamify release was tested with is the fallback: the pinned package (sha256 below),
 # a copy that came with the ISO, and last a build here from the recipe and patch in patches/. Simple files that don't change
 # stay in patches/ and are used as they are.
 #
 # Used by the SteamOS conversion (`gaming_enable`/`gaming_disable`) on every NVIDIA PC (`nvidia_present`); the kernel
 # parameters and the rest of lib/nvidia.sh's setup only on a supported card (`nvidia_supported`): GTX 16 / RTX 20 series or
 # newer (Turing and later, what NVIDIA's open kernel driver supports). Tested on an RTX 5080 only.
 # Sourced by steamify.sh; not meant to be run on its own.
 GSN_PKG=steamify-gamescope-nvidia
 GSN_RELEASES="${GSN_RELEASES:-https://github.com/theupriser/steamify-gamescope-nvidia/releases}"
 # The package this Steamify release was tested with (patches/gamescope-nvidia.PKGBUILD names the same version): the
 # fallback. A new pin: the release's tag, the package's sha256, and the PKGBUILD's pkgver/pkgrel.
 GSN_VERSION=3.16.31-1
 GSN_SHA256=9f20e5243866d1ddeb9ba0c6828bc7be1945f623f9a5d8094391f0df043002e1
 # Where the ISO leaves a copy of the pinned package, for installs without GitHub.
 GSN_BACKUP_DIR="${GSN_BACKUP_DIR:-/usr/local/share/steamify/gamescope}"
 # How long a look at GitHub for a newer release counts (seconds), so opening the menu doesn't ask every time.
 GSN_CHECK_EVERY="${GSN_CHECK_EVERY:-21600}"
 GSN_ENV_LINE='gamescope_drm_gbm_scanout=1'
 GSN_ENV_D="${GSN_ENV_D:-$HOME/.config/environment.d/99-steamify-gamescope-nvidia.conf}"
 GSN_SESSION_ENV="${GSN_SESSION_ENV:-$HOME/.config/gamescope-session/environment}"
 gsn_package_installed() { pacman -Q "$GSN_PKG" >/dev/null 2>&1; }
 gsn_installed_version() { pacman -Q "$GSN_PKG" 2>/dev/null | awk '{print $2}'; }
 gsn_env_set() { [[ -f "$GSN_ENV_D" ]] && grep -qsx "$GSN_ENV_LINE" "$GSN_SESSION_ENV"; }
 gsn_status() { gsn_package_installed && gsn_env_set; }
 gsn_newer() {
    # gsn_newer <a> <b>: version a is newer than b (pacman's own comparison).
    [[ "$(vercmp "$1" "$2" 2>/dev/null)" == 1 ]]
 }
 gsn_latest_tag() {
    # The newest release's tag (<gamescope version>-<package release>), from GitHub; nothing when it can't be reached or
    # there is no release. Follows the redirect of /releases/latest: no API, no rate limit, no JSON. gsn_latest_tag [seconds]
    local url
    url="$(curl -fsL --connect-timeout 4 --max-time "${1:-10}" -o /dev/null -w '%{url_effective}' "$GSN_RELEASES/latest" 2>/dev/null)" || return 1
    url="${url##*/}"
    [[ "$url" =~ ^[0-9][0-9A-Za-z._]*-[0-9]+$ ]] || return 1
    echo "$url"
 }
 gsn_update_pending() {
    # The patched gamescope is installed and GitHub has a newer release: the menu shows the conversion as an update.
    # Looked up at most every GSN_CHECK_EVERY seconds (the answer is kept in the state), quickly, and silently when
    # offline: no network is never a reason to show or hide anything.
    gsn_package_installed || return 1
    local now checked latest
    now="$(date +%s)"; checked="$(state_get gamescope_nvidia checked 0)"
    if (( now - ${checked:-0} > GSN_CHECK_EVERY )); then
        state_set gamescope_nvidia checked "$now"
        latest="$(gsn_latest_tag 5)" && state_set gamescope_nvidia latest "$latest"
    fi
    latest="$(state_get gamescope_nvidia latest)"
    [[ -n "$latest" ]] && gsn_newer "$latest" "$(gsn_installed_version)"
 }
 gsn_sha_of() {
    # The hash a release file is expected to have: the pinned one for the pinned version, else the .sha256 next to the
    # package in the same release (it shows the download wasn't damaged, not who made it).
    local tag="$1" file="$2"
    if [[ "$tag" == "$GSN_VERSION" ]]; then echo "$GSN_SHA256"; return 0; fi
    curl -fsL --connect-timeout 10 --max-time 30 "$GSN_RELEASES/download/$tag/$file.sha256" 2>/dev/null | awk 'NR==1 {print $1}'
 }
 gsn_download() {
    # gsn_download <tag>: the release's package, verified, in the cache; prints its path.
    local tag="$1" cache="${XDG_CACHE_HOME:-$HOME/.cache}/steamify" file want got
    file="$GSN_PKG-$tag-x86_64.pkg.tar.zst"
    mkdir -p "$cache" || return 1
    want="$(gsn_sha_of "$tag" "$file")"
    [[ "$want" =~ ^[0-9a-f]{64}$ ]] || return 1
    if [[ -f "$cache/$file" ]] && [[ "$(sha256sum "$cache/$file" | awk '{print $1}')" == "$want" ]]; then echo "$cache/$file"; return 0; fi
    curl -fsL --retry 2 --connect-timeout 15 --max-time 300 -o "$cache/$file.part" "$GSN_RELEASES/download/$tag/$file" || { rm -f "$cache/$file.part"; return 1; }
    got="$(sha256sum "$cache/$file.part" | awk '{print $1}')"
    if [[ "$got" != "$want" ]]; then rm -f "$cache/$file.part"; return 1; fi
    mv -f "$cache/$file.part" "$cache/$file"
    echo "$cache/$file"
 }
 gsn_fetch_package() {
    # The package to install, as a path, newest first: the newest release on GitHub (not older than the pinned one), else
    # the pinned package (GitHub, the cache, or the copy that came with the ISO). Only files with the expected sha256 count.
    local tag pkg cache="${XDG_CACHE_HOME:-$HOME/.cache}/steamify" file="$GSN_PKG-$GSN_VERSION-x86_64.pkg.tar.zst" copy
    tag="$(gsn_latest_tag)" || tag=""
    if [[ -n "$tag" && "$tag" != "$GSN_VERSION" ]] && gsn_newer "$tag" "$GSN_VERSION"; then
        info "Downloading the newest patched gamescope ($tag)..." >&2
        if pkg="$(gsn_download "$tag")"; then echo "$pkg"; return 0; fi
        warn "Downloading the newest patched gamescope ($tag) failed: using the version this Steamify was tested with ($GSN_VERSION)." >&2
    fi
    info "Downloading the patched gamescope ($GSN_VERSION)..." >&2
    if pkg="$(gsn_download "$GSN_VERSION")"; then echo "$pkg"; return 0; fi
    warn "Downloading the patched gamescope failed (or its checksum didn't match)." >&2
    for copy in "$GSN_BACKUP_DIR/$file" "$cache/$file"; do
        if [[ -f "$copy" ]] && [[ "$(sha256sum "$copy" | awk '{print $1}')" == "$GSN_SHA256" ]]; then
            info "Using the copy that came with Steamify: $copy" >&2
            echo "$copy"; return 0
        fi
    done
    return 1
 }
 gsn_build_package() {
    # Last resort: builds the pinned package from the recipe and patch Steamify carries (patches/), as the user. It
    # downloads gamescope's sources (Valve's repository at the PKGBUILD's pkgver, and its submodules) and compiles them: a
    # few minutes. Prints the package's path.
    local dir cache="${XDG_CACHE_HOME:-$HOME/.cache}/steamify"
    info "Building the patched gamescope here instead (a few minutes)..." >&2
    sudo pacman -S --needed --noconfirm base-devel git >&2 || { err "Installing the build tools failed." >&2; return 1; }
    # On disk, not /tmp: the installer's chroot has a tmpfs there (RAM), and the build is 1-2 GB.
    mkdir -p "$cache" && dir="$(mktemp -d -p "$cache" gamescope-build.XXXXXX)" || return 1
    patch_file gamescope-nvidia.PKGBUILD > "$dir/PKGBUILD" &&
        patch_file gamescope-gbm-scanout.patch > "$dir/gamescope-gbm-scanout.patch" || {
        err "Couldn't write the build files." >&2
        rm -rf "$dir"; return 1
    }
    if ! (cd "$dir" && makepkg -sf --noconfirm --nocheck >&2); then
        err "Building the patched gamescope failed (see above)." >&2
        rm -rf "$dir"; return 1
    fi
    # Moved out, so the build folder can go.
    mv "$(ls "$dir"/"$GSN_PKG"-*.pkg.tar.* 2>/dev/null | grep -v -- '-debug-' | head -1)" "$cache/gamescope-local-build.pkg.tar.zst" ||
        { rm -rf "$dir"; return 1; }
    rm -rf "$dir"
    echo "$cache/gamescope-local-build.pkg.tar.zst"
 }
 gsn_install_package() {
    # The patched gamescope, newest first, each step only when the one before failed: the newest release from GitHub, the
    # pinned package (GitHub, cache or the copy that came with the ISO), a build here. A package that downloaded fine but
    # doesn't install (its libraries differ from this PC's) goes on to the next step too. Nothing else changes before one of
    # them is installed, so a failure leaves the PC as it was, with what it had. --ask 4 lets pacman replace the stock
    # gamescope it conflicts with, and an older patched one.
    local pkg latest have
    have="$(gsn_installed_version)"
    latest="$(gsn_latest_tag)" || latest=""
    # Already the newest (or, offline, the pinned version or newer): nothing to do.
    if [[ -n "$have" ]]; then
        if [[ -n "$latest" ]] && ! gsn_newer "$latest" "$have"; then return 0; fi
        if [[ -z "$latest" ]] && ! gsn_newer "$GSN_VERSION" "$have"; then return 0; fi
    fi
    if pkg="$(gsn_fetch_package)" && sudo pacman -U --noconfirm --ask 4 "$pkg"; then
        ok "Patched gamescope installed."
        return 0
    fi
    warn "The ready-made patched gamescope couldn't be installed."
    [[ -n "$have" ]] && { warn "The installed one ($have) stays."; return 0; }
    if pkg="$(gsn_build_package)" && sudo pacman -U --noconfirm --ask 4 "$pkg"; then
        ok "Patched gamescope built and installed."
        return 0
    fi
    err "The patched gamescope couldn't be installed. The stock gamescope stays."
    return 1
 }
 gsn_env_enable() {
    mkdir -p "$(dirname "$GSN_ENV_D")" "$(dirname "$GSN_SESSION_ENV")"
    echo "$GSN_ENV_LINE" > "$GSN_ENV_D"
    touch "$GSN_SESSION_ENV"
    grep -qsx "$GSN_ENV_LINE" "$GSN_SESSION_ENV" || echo "$GSN_ENV_LINE" >> "$GSN_SESSION_ENV"
 }
 gsn_env_disable() {
    rm -f "$GSN_ENV_D"
    [[ -f "$GSN_SESSION_ENV" ]] && sed -i "/^${GSN_ENV_LINE}\$/d" "$GSN_SESSION_ENV"
    return 0
 }
 gsn_enable() {
    # Only on a supported NVIDIA card; elsewhere the stock gamescope is right.
    nvidia_present || return 0
    # A PC that had "Gaming on NVIDIA" on: Steam must not also start on the desktop.
    nvidia_swap_out
    # What NVIDIA's DRM stack wants (lib/nvidia.sh; a supported card only, the functions check): modeset/fbdev on the
    # kernel command line, the modules in the initramfs, video memory kept over suspend, the 32-bit libraries. Takes
    # effect at the next boot, like the session.
    nvidia_kernel_enable || return 1
    nvidia_extras_enable || return 1
    gsn_install_package || return 1
    gsn_env_enable
    ok "gamescope draws NVIDIA's picture through GBM (gamescope_drm_gbm_scanout=1) from the next gaming mode start."
 }
 gsn_disable() {
    # The setting goes, and what nvidia_*_enable added; the packages stay (patched gamescope, 32-bit libraries), like
    # the other packages of the conversion (steam, gamescope-session-cachyos).
    gsn_env_disable
    nvidia_present || return 0
    nvidia_extras_disable
    nvidia_kernel_disable
 }
@@ -94,8 +94,6 @@ gaming_enable() {
    # LOGIN_MANAGER (sddm with single user, else plasmalogin) is set by the
    # menu. Re-running with the other value switches over cleanly.
    install_required_packages || return 1
    # NVIDIA: gamescope's picture is corrupted unless it is the patched one (no-op elsewhere).
    gsn_enable || return 1
    case "$LOGIN_MANAGER" in
        sddm)
            switch_to_sddm || return 1
@@ -109,8 +107,6 @@ gaming_enable() {
            install_session_sync
            ;;
    esac
    # (NVIDIA with single user mode from before the conversion: its desktop autologin would pin the Plasma session.)
    single_login_release
    create_desktop_shortcut
    steam_enable
    os_name_enable || return 1
@@ -126,11 +122,8 @@ gaming_disable() {
    switch_to_plasmalogin
    remove_desktop_shortcut
    steam_disable
    gsn_disable
    krevert gaming
    os_name_disable
    # NVIDIA with single user mode still on: nothing else logs in by itself any more.
    nvidia_present && single_status && single_login_enable
    ok "The PC boots to the normal login screen again (from the next boot)."
 }
@@ -174,20 +167,6 @@ switch_to_sddm() {
    ok "SDDM is the login manager from the next boot on."
 }
 remove_sddm_base_autologin() {
    # /etc/sddm.conf is read last: an [Autologin] there would override our fragments.
    if [[ -f /etc/sddm.conf ]] && grep -q '^\[Autologin\]' /etc/sddm.conf; then
        backup_file /etc/sddm.conf
        sudo awk '
            /^\[Autologin\]/ { skip=1; next }
            /^\[/ { skip=0 }
            !skip { print }
        ' /etc/sddm.conf | sudo tee /etc/sddm.conf.tmp > /dev/null &&
            sudo mv /etc/sddm.conf.tmp /etc/sddm.conf
        info "Removed [Autologin] from /etc/sddm.conf (backup kept)."
    fi
 }
 configure_sddm_autologin() {
    # User= and Relogin= live in our own fragment; steam-set-session keeps
    # Session= up to date in zz-steamos-autologin.conf, which sorts later
@@ -203,7 +182,16 @@ Session=gamescope-session.desktop
 Relogin=true
 EOF
-    remove_sddm_base_autologin
+    if [[ -f /etc/sddm.conf ]] && grep -q '^\[Autologin\]' /etc/sddm.conf; then
        backup_file /etc/sddm.conf
        sudo awk '
            /^\[Autologin\]/ { skip=1; next }
            /^\[/ { skip=0 }
            !skip { print }
        ' /etc/sddm.conf | sudo tee /etc/sddm.conf.tmp > /dev/null &&
            sudo mv /etc/sddm.conf.tmp /etc/sddm.conf
        info "Removed [Autologin] from /etc/sddm.conf (backup kept)."
    fi
    # Start in gamescope, through CachyOS's own tool so its file is current.
    sudo /usr/lib/steamos/steam-set-session gamescope-session.desktop
@@ -5,19 +5,18 @@
 # 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 silent glyphs nvidia bigpicture nvsilent theme single launcher steamgame notify extended_controller_support vram cec machine poweroff kpin hdmi 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 [silent]=gaming [glyphs]=gaming [bigpicture]=nvidia [nvsilent]=nvidia [steamgame]=launcher [poweroff]=machine [kpin]=machine [hdmi]=machine [bios]=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. HDMI refresh boost needs someone at the
-# screen to confirm each step. Extended controller support builds kernel modules for
+# screen to confirm each step.
-# every installed kernel: opt-in.
+NO_PRESELECT=(boot cec kpin hdmi)
 NO_PRESELECT=(boot silent nvsilent cec kpin hdmi extended_controller_support)
 # 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
@@ -26,25 +25,20 @@ NO_PRESELECT=(boot silent nvsilent cec kpin hdmi extended_controller_support)
 # FEATURE_BASELINE.
 FEATURE_BASELINE=2.1.0
 declare -A FEATURE_VERSION=(
-    [gaming]=2.9.0 [boot]=2.1.0 [silent]=2.11.0 [nvidia]=2.11.2 [bigpicture]=2.10.0 [nvsilent]=2.11.0 [theme]=2.1.0 [glyphs]=2.1.0 [single]=2.1.0
+    [gaming]=2.9.0 [boot]=2.1.0 [theme]=2.1.0 [glyphs]=2.1.0 [single]=2.1.0
-    [launcher]=2.1.0 [cec]=2.7.0 [machine]=2.9.0 [poweroff]=2.2.0 [vram]=2.3.0 [notify]=2.5.0 [steamgame]=2.5.1 [extended_controller_support]=2.10.0
+    [launcher]=2.1.0 [cec]=2.7.0 [machine]=2.9.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"
    [boot]="Boot into the desktop instead of gaming mode"
    [nvidia]="Gaming on NVIDIA: Steam on the desktop, started at login"
    [silent]="Start Steam silently in desktop mode: in the tray at login on the desktop, no window"
    [nvsilent]="Start Steam silently: in the tray at login, no window (untick: Steam's normal window)"
    [bigpicture]="Steam starts in Big Picture: the controller-friendly Steam (untick: Steam's normal window)"
    [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: 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"
    [extended_controller_support]="Extended controller support: Xbox wireless dongle (xone), Xbox controllers over Bluetooth (xpadneo)"
    [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"
@@ -57,14 +51,9 @@ declare -A CURRENT WANTED
 component_available() {
    case "$1" in
        # The SteamOS conversion is offered on NVIDIA PCs too: it installs the patched gamescope there (lib/gamescope-nvidia.sh)
        # and turns off "Gaming on NVIDIA" (lib/nvidia.sh), which is not offered any more (nvidia_available).
        nvidia|bigpicture|nvsilent) nvidia_available ;;
        machine|poweroff) machine_available ;;
        vram) vram_available ;;
-        # Steamify in the Steam library is for gaming mode's controller: not needed for Big Picture on the desktop (NVIDIA PCs;
+        steamgame) steamgame_available ;;
        # shown anyway when it's already on, so it can be turned off).
        steamgame) steamgame_available && { ! nvidia_present || steamgame_status; } ;;
        kpin) kpin_available ;;
        hdmi) hdmi_available ;;
        bios) bios_available ;;
@@ -83,8 +72,6 @@ menu_visible() {
    # Shown in the menu. A sub-option ("Boot into", the kernel pin) only
    # while its parent is ticked.
    component_available "$1" || return 1
    # Silent start is hidden while Steam starts in Big Picture.
    [[ "$1" == nvsilent && "${WANTED[bigpicture]:-0}" == 1 ]] && return 1
    [[ -z "${PARENT[$1]:-}" || "${WANTED[${PARENT[$1]}]:-0}" == 1 ]]
 }
@@ -113,11 +100,7 @@ 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
    # "Gaming on NVIDIA" is on: the SteamOS conversion replaces it, as an update of what the PC has (lib/nvidia.sh).
    [[ "$1" == gaming ]] && nvidia_migration_pending && return 0
    [[ "${CURRENT[$1]:-0}" == 1 ]] || return 1
    # NVIDIA: a newer patched gamescope is out (lib/gamescope-nvidia.sh): a normal run installs it.
    [[ "$1" == gaming ]] && nvidia_present && gsn_update_pending && return 0
    have="$(state_get features "$1" "$FEATURE_BASELINE")"
    [[ "$have" == off ]] && have="$FEATURE_BASELINE"
    want="${FEATURE_VERSION[$1]:-$FEATURE_BASELINE}"
@@ -130,7 +113,7 @@ menu_label() {
    # last run.
    local l="${LABEL[$1]}" b=""
    if feature_outdated "$1"; then b="${c_yellow}(update)${c_reset}"
-    elif feature_new "$1" || feature_new_optin "$1"; then b="${c_green}(new)${c_reset}"; fi
+    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
@@ -138,28 +121,14 @@ menu_label() {
    printf '%s' "$l"
 }
 feature_added() {
    # An 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, or
    # "Gaming on NVIDIA" where that replaces it, as its parent), not on yet,
    # with no record: shown as "new".
    local p="${PARENT[$1]:-}" parent_on=0
    if [[ -n "$p" ]]; then parent_on="${CURRENT[$p]:-0}"
    elif [[ "${CURRENT[gaming]:-0}" == 1 || "${CURRENT[nvidia]:-0}" == 1 ]]; then parent_on=1; fi
    [[ "$1" != gaming && "$parent_on" == 1 && "${CURRENT[$1]:-0}" == 0 ]] &&
        ! is_action "$1" && component_selectable "$1" &&
        [[ -z "$(state_get features "$1")" ]]
 }
 feature_new() {
-    # A new default option: ticked for you (never turned on or off by itself).
+    # A default option added after its parent was set up (e.g. the power-off
-    feature_added "$1" && [[ " ${NO_PRESELECT[*]} " != *" $1 "* ]]
+    # 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}"
-feature_new_optin() {
+    [[ "$1" != gaming && "${CURRENT[$p]:-0}" == 1 && "${CURRENT[$1]:-0}" == 0 ]] &&
-    # A new opt-in option (unticked by default): the "new" badge only, it stays
+        ! is_action "$1" && component_selectable "$1" && [[ " ${NO_PRESELECT[*]} " != *" $1 "* ]] &&
-    # unticked. Boot into is a choice row of the conversion, not an item.
+        [[ -z "$(state_get features "$1")" ]]
    feature_added "$1" && [[ "$1" != boot && " ${NO_PRESELECT[*]} " == *" $1 "* ]]
 }
 component_selectable() {
@@ -172,7 +141,6 @@ component_selectable() {
 detect_components() {
    local c any=false
    for c in "${COMPONENTS[@]}"; do CURRENT[$c]=0; WANTED[$c]=0; done
    for c in "${COMPONENTS[@]}"; do
        component_available "$c" || continue
        if "${c}_status"; then CURRENT[$c]=1; any=true; else CURRENT[$c]=0; fi
@@ -186,17 +154,6 @@ detect_components() {
        component_available "$c" || continue
        { feature_outdated "$c" || feature_new "$c"; } && WANTED[$c]=1
    done
    # "Gaming on NVIDIA" was on: its replacement, the SteamOS conversion, comes with the defaults of a first run, and the
    # PC starts the way it did: Steam in Big Picture at login becomes booting into gaming mode, any other Steam start
    # (a normal window, or silent in the tray) becomes booting into the desktop, with the silent start kept.
    if nvidia_migration_pending; then
        WANTED[glyphs]=1
        if bigpicture_status; then WANTED[boot]=0
        else
            WANTED[boot]=1
            nvsilent_status && WANTED[silent]=1
        fi
    fi
    # 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.
@@ -265,7 +222,7 @@ defaults_options() {
                warn "Leaving out ${LABEL[$c]%%:*}: not available on this PC."
            fi
        done
-        [[ "${WANTED[single]}" == 1 ]] && component_available gaming && WANTED[gaming]=1
+        [[ "${WANTED[single]}" == 1 ]] && WANTED[gaming]=1
        for c in "${COMPONENTS[@]}"; do
            [[ "${WANTED[$c]}" == 1 && -n "${PARENT[$c]:-}" ]] && WANTED[${PARENT[$c]}]=1
        done
@@ -299,7 +256,7 @@ defaults_list() {
        [[ "$c" == cec ]] && machine_available && on=true
        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[$c]:-}"),\"needs\":\"\",\"hideWhen\":$(json_str "$([[ "$c" == nvsilent ]] && echo bigpicture)"),\"on\":$on,\"selectable\":$sel}"
+        items+=",\"kind\":\"$kind\",\"parent\":$(json_str "${PARENT[$c]:-}"),\"on\":$on,\"selectable\":$sel}"
    done
    printf '[%s]\n' "$items"
 }
@@ -309,19 +266,10 @@ toggle_component() {
    component_selectable "$c" || return 1
    WANTED[$c]=$(( 1 - WANTED[$c] ))
    # Single user mode only makes sense on top of the SteamOS conversion.
-    if [[ "$c" == single && "${WANTED[single]}" == 1 ]] && component_available gaming; then WANTED[gaming]=1; fi
+    if [[ "$c" == single && "${WANTED[single]}" == 1 ]]; then WANTED[gaming]=1; fi
    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
    # Big Picture is opt-out: ticked along with "Gaming on NVIDIA".
    if [[ "$c" == nvidia ]]; then WANTED[bigpicture]=${WANTED[nvidia]}; fi
    if [[ "$c" == bigpicture && "${WANTED[bigpicture]}" == 1 ]]; then WANTED[nvidia]=1; WANTED[nvsilent]=0; fi
    # Silent and Big Picture exclude each other.
    if [[ "$c" == nvsilent && "${WANTED[nvsilent]}" == 1 ]]; then WANTED[nvidia]=1; WANTED[bigpicture]=0; fi
    if [[ "$c" == nvidia && "${WANTED[nvidia]}" == 0 ]]; then WANTED[nvsilent]=0; fi
    if [[ "$c" == gaming && "${WANTED[gaming]}" == 0 ]]; then WANTED[silent]=0; WANTED[glyphs]=0; fi
    if [[ "$c" == silent && "${WANTED[silent]}" == 1 ]]; then WANTED[gaming]=1; fi
    if [[ "$c" == glyphs && "${WANTED[glyphs]}" == 1 ]]; then WANTED[gaming]=1; 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
@@ -511,11 +459,6 @@ apply_changes() {
        if "${c}_disable"; then feature_record "$c" disable; else failed+=("$c"); fi
    done
    for c in "${TO_ENABLE[@]}"; do
        # A sub-option of something that just failed isn't applied: it would be left on without its parent.
        if [[ -n "${PARENT[$c]:-}" && " ${failed[*]:-} " == *" ${PARENT[$c]} "* ]]; then
            warn "Skipping ${LABEL[$c]%%:*}: ${LABEL[${PARENT[$c]}]%%:*} didn't work."
            continue
        fi
        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
@@ -1,339 +0,0 @@
 #!/bin/bash
 # Gaming on NVIDIA PCs: the SteamOS conversion (gamescope session) isn't offered there, because gamescope's DRM session shows a
 # corrupted picture on NVIDIA (NVIDIA's open bug 5240452: modes above 2560x1440@120). `nvidia` is the replacement: Steam on the
 # Plasma desktop, installed when missing and started at login; `bigpicture` (a sub-option) makes it start in Big Picture.
 # On a supported card (RTX 20 series or newer, `nvidia_supported`) it also sets up what NVIDIA's Wayland/DRM stack wants:
 # nvidia-drm.modeset=1 and fbdev=1 on the kernel command line and the NVIDIA modules in the initramfs. That didn't cure
 # gamescope's picture (the driver already reported both `Y`), but it is the standard setup and may be needed.
 # Sourced by steamify.sh; not meant to be run on its own.
 NVIDIA_UNIT=steamify-steam-autostart.service
 NVIDIA_PARAMS="nvidia-drm.modeset=1 nvidia-drm.fbdev=1"
 NVIDIA_INITRAMFS_CONF=${NVIDIA_INITRAMFS_CONF:-/etc/mkinitcpio.conf.d/90-steamify-nvidia.conf}
 # The script and pacman hook that keep the initramfs file right at every kernel change.
 NVIDIA_SCRIPT=${NVIDIA_SCRIPT:-/usr/local/libexec/steamify-nvidia-initramfs}
 NVIDIA_HOOK=${NVIDIA_HOOK:-/etc/pacman.d/hooks/85-steamify-nvidia-initramfs.hook}
 # Keeps video memory over suspend (with the nvidia-suspend/resume services).
 NVIDIA_MODPROBE=${NVIDIA_MODPROBE:-/etc/modprobe.d/90-steamify-nvidia.conf}
 NVIDIA_SLEEP_UNITS="nvidia-suspend.service nvidia-resume.service nvidia-hibernate.service"
 # 32-bit parts Steam games and the 32-bit MangoHud preload need.
 NVIDIA_LIB32_PKGS="lib32-nvidia-utils lib32-libxkbcommon"
 # The running kernel's command line; the tests point this at a file.
 NVIDIA_CMDLINE=${NVIDIA_CMDLINE:-/proc/cmdline}
 # The DRM devices in sysfs; the tests point this at a fake tree.
 NVIDIA_DRM_DIR=${NVIDIA_DRM_DIR:-/sys/class/drm}
 nvidia_unit_file() { echo "$HOME/.config/systemd/user/$NVIDIA_UNIT"; }
 nvidia_present() {
    # An NVIDIA GPU (PCI vendor 0x10de, display class) whose driver provides
    # nvidia_drm. nouveau has none, and gamescope is not a problem there.
    local d
    for d in "$NVIDIA_DRM_DIR"/card[0-9]*/device; do
        [[ "$(cat "$d/vendor" 2>/dev/null)" == 0x10de ]] || continue
        [[ "$(cat "$d/class" 2>/dev/null)" == 0x03* ]] || continue
        modinfo nvidia_drm >/dev/null 2>&1 && return 0
    done
    return 1
 }
 # Not offered any more (2.11.2): the SteamOS conversion with the patched gamescope (lib/gamescope-nvidia.sh) covers NVIDIA PCs.
 # A PC that has this on keeps it until the conversion is turned on, which calls nvidia_swap_out.
 nvidia_available() { return 1; }
 nvidia_migration_pending() {
    # "Gaming on NVIDIA" is on (set up before 2.11.2) and the SteamOS conversion that replaces it isn't: the menu ticks the
    # conversion and shows it as an update, so a normal run moves the PC over (nvidia_swap_out in gsn_enable).
    nvidia_present && nvidia_status && ! gaming_status 2>/dev/null
 }
 nvidia_swap_out() {
    # The conversion takes over: Steam no longer starts by itself on the desktop at login (both would start it). Steam, the
    # packages and the NVIDIA settings stay: the conversion needs them too. The state stays for the conversion's own disable.
    nvidia_status || return 0
    info "Gaming on NVIDIA is replaced by the SteamOS conversion: Steam no longer starts on the desktop at login."
    user_systemctl disable --now "$NVIDIA_UNIT" >/dev/null 2>&1
    rm -f "$(nvidia_unit_file)"
    user_systemctl daemon-reload
    krevert bigpicture
    return 0
 }
 bigpicture_available() { nvidia_available; }
 nvidia_status() {
    pacman -Q steam >/dev/null 2>&1 && [[ -f "$(nvidia_unit_file)" ]] &&
        user_systemctl is-enabled -q "$NVIDIA_UNIT" 2>/dev/null
 }
 nvidia_write_unit() {
    # nvidia_write_unit [args]: the autostart unit, Steam started with those arguments.
    local unit; unit="$(nvidia_unit_file)"
    mkdir -p "$(dirname "$unit")"
    service_file steamify-steam-autostart.service ARGS="$1" > "$unit" || { err "Writing $unit failed."; return 1; }
    user_systemctl daemon-reload
 }
 nvidia_enable() {
    info "Gaming on NVIDIA: Steam on the desktop, started at login..."
    if ! pacman -Q steam >/dev/null 2>&1; then
        sudo pacman -S --needed --noconfirm steam || { err "Installing Steam failed."; return 1; }
        state_set nvidia installed_pkgs steam
    fi
    # Keeps what the Big Picture option set up; a first run starts Steam normally.
    local unit_args=""
    if bigpicture_status; then unit_args=-gamepadui; elif nvsilent_status; then unit_args=-silent; fi
    nvidia_write_unit "$unit_args" || return 1
    user_systemctl enable "$NVIDIA_UNIT" >/dev/null 2>&1 || { err "Enabling $NVIDIA_UNIT failed."; return 1; }
    nvidia_kernel_enable || return 1
    nvidia_extras_enable || return 1
    ok "Steam starts at your next login."
 }
 nvidia_disable() {
    local pkgs unit; unit="$(nvidia_unit_file)"
    user_systemctl disable --now "$NVIDIA_UNIT" >/dev/null 2>&1
    rm -f "$unit"
    user_systemctl daemon-reload
    # Swapped for the SteamOS conversion (turned on first, in the same run): it needs the same settings, they stay.
    gaming_status 2>/dev/null || nvidia_extras_disable
    pkgs="$(state_get nvidia installed_pkgs)"
    if gaming_status 2>/dev/null; then
        local p; pkgs=" $pkgs "
        for p in $NVIDIA_LIB32_PKGS; do pkgs="${pkgs// $p / }"; done
    fi
    # Only what Steamify installed; games and the Steam folder stay.
    # shellcheck disable=SC2086 # a list of package names
    [[ -n "$pkgs" ]] && sudo pacman -Rns --noconfirm $pkgs >/dev/null 2>&1
    state_clear nvidia
    krevert bigpicture
    gaming_status 2>/dev/null || nvidia_kernel_disable
    ok "Steam no longer starts at login."
 }
 bigpicture_status() { grep -qs -- '-gamepadui' "$(nvidia_unit_file)"; }
 bigpicture_enable() {
    # The unit comes from nvidia_enable (it runs first); without it there is nothing to change.
    [[ -f "$(nvidia_unit_file)" ]] || return 0
    nvidia_write_unit -gamepadui || return 1
    # Windows of the last session (Discord, a browser) would be restored on top of Big Picture.
    kset bigpicture ksmserverrc General loginMode emptySession
    ok "Steam starts in Big Picture at your next login, on an empty desktop."
 }
 bigpicture_disable() {
    krevert bigpicture
    [[ -f "$(nvidia_unit_file)" ]] || return 0
    nvidia_write_unit "" && ok "Steam starts in its normal window at your next login."
 }
 # Sub-option: Steam starts silently (tray only, no window). Big Picture and
 # a silent start exclude each other (the menus untick one when the other is
 # ticked); a first run with both gets Big Picture.
 nvsilent_status() { grep -qs -- '-silent' "$(nvidia_unit_file)"; }
 nvsilent_enable() {
    [[ -f "$(nvidia_unit_file)" ]] || return 0
    bigpicture_status && return 0
    nvidia_write_unit -silent || return 1
    ok "Steam starts silently at your next login."
 }
 nvsilent_disable() {
    nvsilent_status || return 0
    nvidia_write_unit "" && ok "Steam starts in its normal window at your next login."
 }
 # --- Kernel parameters and early modules (a supported card only)
 nvidia_supported() {
    # A supported NVIDIA GPU: PCI vendor 0x10de, display class, its kernel
    # driver installed, and not older than Turing (GTX 16 / RTX 20 series: the cards NVIDIA's open kernel driver supports), decided like the
    # VRAM booster does (vram_nvidia_legacy_id: chwd's legacy card lists, every
    # other card runs NVIDIA's open modules). Older cards are left alone.
    local d
    for d in "$NVIDIA_DRM_DIR"/card[0-9]*/device; do
        [[ "$(cat "$d/vendor" 2>/dev/null)" == 0x10de ]] || continue
        [[ "$(cat "$d/class" 2>/dev/null)" == 0x03* ]] || continue
        vram_nvidia_legacy_id "$(cat "$d/device" 2>/dev/null)" && continue
        modinfo nvidia_drm >/dev/null 2>&1 && return 0
    done
    return 1
 }
 nvidia_legacy_gpu() {
    # 0 when the only NVIDIA GPU(s) are older than RTX 20 (reported, not fixed).
    local d found=0
    for d in "$NVIDIA_DRM_DIR"/card[0-9]*/device; do
        [[ "$(cat "$d/vendor" 2>/dev/null)" == 0x10de && "$(cat "$d/class" 2>/dev/null)" == 0x03* ]] || continue
        vram_nvidia_legacy_id "$(cat "$d/device" 2>/dev/null)" || return 1
        found=1
    done
    [[ $found == 1 ]]
 }
 nvidia_boot_file() {
    # Same boot loaders as the kernel command line elsewhere (lib/hdmi-refresh.sh).
    hdmi_boot_file
 }
 nvidia_param_set() {
    # 0 when $1 (e.g. nvidia-drm.modeset=1) is on the kernel command line or
    # already in the boot loader's file (not booted yet).
    # The kernel treats "nvidia_drm" and "nvidia-drm" alike: CachyOS' own
    # setup may already have written the underscore spelling.
    local f re; f="$(nvidia_boot_file)"; re="${1//nvidia-drm/nvidia[-_]drm}"
    grep -qwE -- "$re" "$NVIDIA_CMDLINE" 2>/dev/null ||
        { [[ -n "$f" ]] && grep -qwE -- "$re" "$f" 2>/dev/null; }
 }
 nvidia_params_missing() {
    local p
    for p in $NVIDIA_PARAMS; do nvidia_param_set "$p" || return 0; done
    return 1
 }
 nvidia_initramfs_ok() {
    [[ -f "$NVIDIA_INITRAMFS_CONF" ]] || grep -qE '^MODULES=.*nvidia_drm' /etc/mkinitcpio.conf 2>/dev/null
 }
 nvidia_modules_everywhere() {
    # 0 when every installed kernel has the nvidia_drm module (the script's own check).
    patch_file steamify-nvidia-initramfs.sh | NVIDIA_MODULES_DIR="${NVIDIA_MODULES_DIR:-/usr/lib/modules}" bash -s check
 }
 nvidia_hook_install() {
    # Never installs an empty script or hook (a piped patch_file that failed
    # still lets install succeed with no input).
    local script hook
    script="$(patch_file steamify-nvidia-initramfs.sh)" && [[ -n "$script" ]] &&
        hook="$(patch_file steamify-nvidia-initramfs.hook | fill SCRIPT="$NVIDIA_SCRIPT")" && [[ -n "$hook" ]] || return 1
    printf '%s\n' "$script" | sudo install -Dm755 /dev/stdin "$NVIDIA_SCRIPT" &&
        printf '%s\n' "$hook" | sudo install -Dm644 /dev/stdin "$NVIDIA_HOOK"
 }
 nvidia_rebuild_boot() {
    local f; f="$(nvidia_boot_file)"
    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 ;;
        *) sudo /usr/bin/mkinitcpio -P ;;
    esac
 }
 nvidia_boot_has_params() {
    # 0 when the generated boot entries carry the parameters (or can't be
    # checked): limine.conf, systemd-boot's entries, grub.cfg.
    local target
    case "$1" in
        */limine) target="${NVIDIA_LIMINE_CONF:-/boot/limine.conf}" ;;
        */sdboot-manage.conf) target="${NVIDIA_SDBOOT_DIR:-/boot/loader/entries}" ;;
        */grub) target="${NVIDIA_GRUB_CFG:-/boot/grub/grub.cfg}" ;;
        *) return 0 ;;
    esac
    sudo test -e "$target" || return 0
    sudo grep -rqs 'nvidia-drm.modeset=1' "$target"
 }
 nvidia_kernel_enable() {
    nvidia_supported || return 0
    local f changed=0 p; f="$(nvidia_boot_file)"
    if nvidia_params_missing; then
        if [[ -z "$f" ]]; then
            warn "NVIDIA GPU found, but no supported boot loader: add '$NVIDIA_PARAMS' to the kernel command line yourself."
        else
            info "NVIDIA GPU found: adding $NVIDIA_PARAMS to the kernel command line (fixes a corrupted screen in gaming mode)..."
            backup_file "$f"
            case "$f" in
                */limine)
                    sudo sed -i -E "s/^(KERNEL_CMDLINE\[default\]\+?=\"[^\"]*)\"/\1 $NVIDIA_PARAMS\"/" "$f" ;;
                */sdboot-manage.conf)
                    sudo sed -i -E "s/^(LINUX_OPTIONS=\"[^\"]*)\"/\1 $NVIDIA_PARAMS\"/" "$f" ;;
                */grub)
                    sudo sed -i -E "s/^(GRUB_CMDLINE_LINUX_DEFAULT=\"[^\"]*)\"/\1 $NVIDIA_PARAMS\"/" "$f" ;;
            esac
            if ! grep -q "nvidia-drm.fbdev=1" "$f"; then
                err "Couldn't add the NVIDIA parameters to $f (no kernel command line setting in it): add '$NVIDIA_PARAMS' yourself."
                return 1
            fi
            changed=1
        fi
    fi
    nvidia_hook_install || { err "Installing the NVIDIA initramfs hook failed."; return 1; }
    local had=0; [[ -f "$NVIDIA_INITRAMFS_CONF" ]] && had=1
    sudo env NVIDIA_INITRAMFS_CONF="$NVIDIA_INITRAMFS_CONF" NVIDIA_MODULES_DIR="${NVIDIA_MODULES_DIR:-/usr/lib/modules}" "$NVIDIA_SCRIPT" sync
    if [[ -f "$NVIDIA_INITRAMFS_CONF" && $had == 0 ]]; then
        info "Loading the NVIDIA modules early (initramfs)..."
        changed=1
    elif [[ ! -f "$NVIDIA_INITRAMFS_CONF" && $had == 1 ]]; then
        warn "A kernel without the NVIDIA modules is installed: not loading them early any more (rebuilding the initramfs without them)."
        changed=1
    elif [[ ! -f "$NVIDIA_INITRAMFS_CONF" ]] && ! nvidia_initramfs_ok; then
        warn "Not every installed kernel has the NVIDIA modules: not loading them early for now (the kernel parameters still apply; this is checked again at every kernel update)."
    fi
    if [[ $changed == 1 ]]; then
        nvidia_rebuild_boot || { err "Rebuilding the boot entries failed."; return 1; }
        if ! nvidia_boot_has_params "$f"; then
            err "The boot entries don't have the NVIDIA parameters: the initramfs or boot entry build failed (see above)."
            return 1
        fi
        ok "NVIDIA gaming mode fix applied; it takes effect after a reboot."
    fi
    return 0
 }
 nvidia_extras_enable() {
    # Video memory kept over sleep, the matching services and the 32-bit libraries (a supported card only).
    nvidia_supported || return 0
    local pkg u units="" prev missing=()
    if [[ ! -f "$NVIDIA_MODPROBE" ]]; then
        info "Keeping video memory over suspend (NVreg_PreserveVideoMemoryAllocations=1)..."
        printf '%s\n' '# Added by Steamify (Gaming on NVIDIA)' 'options nvidia NVreg_PreserveVideoMemoryAllocations=1' |
            sudo tee "$NVIDIA_MODPROBE" >/dev/null || { err "Writing $NVIDIA_MODPROBE failed."; return 1; }
        # The NVIDIA modules load from the initramfs, which carries modprobe.d.
        nvidia_rebuild_boot || warn "Rebuilding the initramfs failed: the suspend setting applies once it is rebuilt."
    fi
    for u in $NVIDIA_SLEEP_UNITS; do
        systemctl is-enabled -q "$u" 2>/dev/null && continue
        sudo systemctl enable "$u" >/dev/null 2>&1 && units+="${units:+ }$u"
    done
    if [[ -n "$units" ]]; then
        prev="$(state_get nvidia enabled_units)"
        state_set nvidia enabled_units "${prev:+$prev }$units"
    fi
    for pkg in $NVIDIA_LIB32_PKGS; do pacman -Q "$pkg" >/dev/null 2>&1 || missing+=("$pkg"); done
    if [[ ${#missing[@]} -gt 0 ]]; then
        info "Installing the 32-bit libraries games need: ${missing[*]}"
        if sudo pacman -S --needed --noconfirm "${missing[@]}"; then
            prev="$(state_get nvidia installed_pkgs)"
            state_set nvidia installed_pkgs "${prev:+$prev }${missing[*]}"
        else
            warn "Installing ${missing[*]} failed (is [multilib] enabled in /etc/pacman.conf?): 32-bit games may not start."
        fi
    fi
    return 0
 }
 nvidia_extras_disable() {
    # Only what Steamify enabled; the 32-bit packages go with installed_pkgs.
    local u
    for u in $(state_get nvidia enabled_units); do sudo systemctl disable "$u" >/dev/null 2>&1; done
    if [[ -f "$NVIDIA_MODPROBE" ]]; then
        sudo rm -f "$NVIDIA_MODPROBE"
        nvidia_rebuild_boot || true
    fi
 }
 nvidia_kernel_disable() {
    local f changed=0; f="$(nvidia_boot_file)"
    if [[ -n "$f" ]] && grep -q "$NVIDIA_PARAMS" "$f" 2>/dev/null; then
        sudo sed -i "s/ \?$NVIDIA_PARAMS//" "$f"
        changed=1
    fi
    [[ -f "$NVIDIA_INITRAMFS_CONF" ]] && { sudo rm -f "$NVIDIA_INITRAMFS_CONF"; changed=1; }
    sudo rm -f "$NVIDIA_HOOK" "$NVIDIA_SCRIPT"
    [[ $changed == 1 ]] && nvidia_rebuild_boot
    return 0
 }
@@ -58,30 +58,6 @@ bootstrap_yay() {
    fi
 }
 python_hid_shim_ensure() {
    # jupiter-hw-support (a dependency of gamescope-session-cachyos) wants python-hid, which conflicts with python-hidapi, and
    # a PC can need python-hidapi (liquidctl does). Only Valve's Steam Deck controller firmware updater uses python-hid, which
    # a PC doesn't run: so a placeholder package that provides python-hid keeps python-hidapi and satisfies the dependency
    # (also at later updates, which a one-time --assume-installed wouldn't). It stays when the conversion goes off:
    # jupiter-hw-support, which stays, depends on it.
    pacman -Q python-hidapi >/dev/null 2>&1 || return 0
    pacman -Q python-hid steamify-python-hid-shim >/dev/null 2>&1 && return 0
    local dir pkg cache="${XDG_CACHE_HOME:-$HOME/.cache}/steamify"
    warn "python-hidapi is installed (liquidctl and others need it) and conflicts with python-hid, which Steam Deck's tools ask for: keeping python-hidapi, with a small placeholder package for python-hid."
    sudo pacman -S --needed --noconfirm base-devel >/dev/null || { err "Installing the build tools failed."; return 1; }
    mkdir -p "$cache" && dir="$(mktemp -d -p "$cache" hid-shim.XXXXXX)" || return 1
    patch_file python-hid-shim.PKGBUILD > "$dir/PKGBUILD" || { rm -rf "$dir"; return 1; }
    if ! (cd "$dir" && makepkg -f --noconfirm >/dev/null) ||
        ! pkg="$(ls "$dir"/steamify-python-hid-shim-*.pkg.tar.* 2>/dev/null | head -1)" ||
        ! sudo pacman -U --noconfirm "$pkg"; then
        rm -rf "$dir"
        err "Couldn't set up the python-hid placeholder: python-hidapi and python-hid conflict, so the packages can't be installed."
        return 1
    fi
    rm -rf "$dir"
    ok "python-hidapi kept; python-hid is covered by a placeholder."
 }
 install_required_packages() {
    # Step 2: gamescope/Steam and the desktop helpers the rest of the setup uses.
    local -a MISSING
@@ -89,7 +65,6 @@ install_required_packages() {
    mapfile -t MISSING < <(pacman -T gamescope-session-cachyos steam mangohud xterm ttf-liberation wqy-zenhei plasma-keyboard)
    if [[ ${#MISSING[@]} -gt 0 ]]; then
        python_hid_shim_ensure || return 1
        info "Installing missing packages: ${MISSING[*]}"
        sudo pacman -S --needed --noconfirm "${MISSING[@]}" || { err "Package installation failed."; return 1; }
    else
@@ -119,45 +119,7 @@ single_launcher_drop() {
    return 0
 }
 # Without the SteamOS conversion (NVIDIA PCs: gamescope's session is broken there) nothing logs in by itself, so single user
 # mode does it: SDDM, autologin into the Plasma session. Named to sort after steam-set-session's zz-steamos-autologin.conf,
 # which may still say gamescope from an earlier conversion.
 SINGLE_AUTOLOGIN=${SINGLE_AUTOLOGIN:-/etc/sddm.conf.d/zzz-steamify-autologin.conf}
 single_login_needed() { nvidia_present && ! gaming_status; }
 single_login_enable() {
    single_login_needed || return 0
    switch_to_sddm || return 1
    info "Logging in to the desktop by itself (SDDM autologin for $TARGET_USER)..."
    sudo mkdir -p "$(dirname "$SINGLE_AUTOLOGIN")"
    sudo tee "$SINGLE_AUTOLOGIN" > /dev/null << EOF
 [Autologin]
 User=$TARGET_USER
 Session=plasma.desktop
 Relogin=true
 EOF
    remove_sddm_base_autologin
 }
 single_login_release() {
    # The SteamOS conversion logs in by itself, and picks the session (gamescope, or the desktop with "Boot into"): the
    # desktop autologin above, which sorts last, would pin the Plasma session and "Return to Gaming Mode" would open KDE
    # again. Called when the conversion is turned on; turning it off sets it up again (gaming_disable).
    [[ -f "$SINGLE_AUTOLOGIN" ]] || return 0
    info "The SteamOS conversion logs in by itself: removing the desktop autologin of single user mode."
    sudo rm -f "$SINGLE_AUTOLOGIN"
 }
 single_login_disable() {
    [[ -f "$SINGLE_AUTOLOGIN" ]] || return 0
    sudo rm -f "$SINGLE_AUTOLOGIN"
    # The way back is CachyOS's own login manager, unless the conversion is on (it keeps SDDM).
    gaming_status || switch_to_plasmalogin
 }
 single_enable() {
    single_login_enable || return 1
    info "Turning off the lock screen, user switching and logging out..."
    stop_plasmashell_for_edit
@@ -183,7 +145,6 @@ single_enable() {
 }
 single_disable() {
    single_login_disable
    info "Restoring the lock screen, user switching and logging out..."
    stop_plasmashell_for_edit
    if has_journal single; then
@@ -5,63 +5,35 @@
 steam_enable() {
    info "Applying non-optional SteamOS environment & keyboard fixes..."
-    local steam_env_dir
+    local steam_env_dir systemd_user_dir
    steam_env_dir="$HOME/.config/environment.d"
    mkdir -p "$steam_env_dir"
    # 2. Prevent KDE Wayland from blocking the virtual keyboard overlay
    echo "KWIN_IM_SHOW_ALWAYS=1" > "$steam_env_dir/99-kde-virtual-keyboard.conf"
-    ok "Steam UI parameters and keyboard fix deployed successfully."
+    # 3. Setup robust background systemd service for Steam autostart on Desktop Mode
-}
+    systemd_user_dir="$HOME/.config/systemd/user"
    mkdir -p "$systemd_user_dir"
-# Sub-option of the SteamOS conversion: Steam starts silently (in the tray,
+    service_file steam-desktop-autostart.service > "$systemd_user_dir/steam-desktop-autostart.service"
 # no window) on the Plasma desktop. It is Steam's own autostart entry, the file
 # Steam's setting "Run Steam when my computer starts" creates and removes, so
 # that setting shows what Steamify did (and the other way around). Steam's copy
 # is the system steam.desktop; ours has -silent in its Exec line.
 STEAM_AUTOSTART="${XDG_CONFIG_HOME:-$HOME/.config}/autostart/steam.desktop"
 STEAM_SYSTEM_DESKTOP=/usr/share/applications/steam.desktop
-silent_status() {
+    # Clean out old .desktop shortcut so they don't fight
-    # The old systemd unit counts as on too (until it is migrated by an update of this option).
+    rm -f "$HOME/.config/autostart/steam.desktop"
    grep -qs '^Exec=.*-silent' "$STEAM_AUTOSTART" ||
        [[ -f "$HOME/.config/systemd/user/steam-desktop-autostart.service" ]]
 }
-silent_old_unit_remove() {
+    # Reload user systemd context and activate the background loop
    # Before 2.11.0 the option was a systemd user unit: it would start Steam a second time.
    local unit="$HOME/.config/systemd/user/steam-desktop-autostart.service"
    [[ -f "$unit" ]] || return 0
    user_systemctl disable --now steam-desktop-autostart.service 2>/dev/null
    rm -f "$unit"
    user_systemctl daemon-reload
-}
+    user_systemctl enable --now steam-desktop-autostart.service
-silent_enable() {
+    ok "Steam UI parameters and keyboard autostart deployed successfully."
    silent_old_unit_remove
    mkdir -p "$(dirname "$STEAM_AUTOSTART")"
    if [[ -f "$STEAM_SYSTEM_DESKTOP" ]]; then
        sed 's|^Exec=/usr/bin/steam %U$|Exec=/usr/bin/steam -silent %U|' "$STEAM_SYSTEM_DESKTOP" > "$STEAM_AUTOSTART"
    fi
    silent_status || printf '%s\n' '[Desktop Entry]' 'Name=Steam' 'Exec=/usr/bin/steam -silent %U' \
        'Icon=steam' 'Terminal=false' 'Type=Application' 'Categories=Network;FileTransfer;Game;' > "$STEAM_AUTOSTART"
    ok "Steam starts silently on the desktop from the next login."
 }
 silent_disable() {
    silent_old_unit_remove
    silent_status && rm -f "$STEAM_AUTOSTART"
    ok "Steam no longer starts by itself on the desktop."
 }
 steam_disable() {
-    info "Removing Steam desktop settings..."
+    info "Removing Steam desktop autostart..."
-    # The autostart entry is the `silent` option's: removed with it, and here
+    user_systemctl disable --now steam-desktop-autostart.service 2>/dev/null
-    # too for when the conversion goes off by itself.
+    rm -f "$HOME/.config/systemd/user/steam-desktop-autostart.service" \
-    silent_status && silent_disable
+        "$HOME/.config/environment.d/99-kde-virtual-keyboard.conf"
-    silent_old_unit_remove
+    user_systemctl daemon-reload
    rm -f "$HOME/.config/environment.d/99-kde-virtual-keyboard.conf"
    ok "Steam desktop settings removed (takes full effect at next login)."
 }
@@ -56,7 +56,7 @@ steamgame_steam_busy() {
 steamgame_edit() {
    # steamgame_edit <function>: runs it with Steam closed, then starts Steam
-    # again if it was running (silently, in the tray).
+    # 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
@@ -72,7 +72,11 @@ steamgame_edit() {
    fi
    "$1"; local rc=$?
    if [[ "$was_running" == true ]]; then
-        systemd-run --user --collect -q steam -silent >/dev/null 2>&1
+        if user_systemctl is-enabled -q steam-desktop-autostart.service 2>/dev/null; then
            user_systemctl 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"
@@ -407,12 +407,9 @@ wifi_backend_disable() {
 serial_enable() {
    printf '%s\n' "# Written by Steamify: Steam shows the serial number, like on SteamOS." \
-        'z /sys/class/dmi/id/product_serial 0444 - - -' | sudo tee "$SERIAL_TMPFILES" > /dev/null ||
+        'z /sys/class/dmi/id/product_serial 0444 - - -' | sudo tee "$SERIAL_TMPFILES" > /dev/null &&
        sudo systemd-tmpfiles --create "$SERIAL_TMPFILES" ||
        { err "Making the serial number readable for Steam failed."; return 1; }
    # The file applies at every boot; now too, unless /sys is read-only (the ISO's installer runs in a chroot).
    sudo systemd-tmpfiles --create "$SERIAL_TMPFILES" 2>/dev/null ||
        info "The serial number becomes readable for Steam at the next boot."
    return 0
 }
 serial_disable() {
@@ -106,32 +106,17 @@ theme_enable() {
    # SteamOS panel, launcher icon and wallpaper. It needs plasmashell up.
    lookandfeeltool -a "$VAPOR_LOOKANDFEEL" --resetLayout >/dev/null 2>&1 ||
        { err "lookandfeeltool failed."; return 1; }
-    # The new layout has a new launcher, without single user's settings, and the default taskbar pins.
+    # The new layout has a new launcher, without single user's settings.
-    sleep 3
+    if single_status; then
-    stop_plasmashell_for_edit
+        sleep 3
-    taskbar_drop_discover
+        stop_plasmashell_for_edit
-    single_status && single_launcher
+        single_launcher
-    restart_plasmashell_if_stopped
+        restart_plasmashell_if_stopped
    fi
    extras_enable || warn "SteamOS desktop extras not installed (see above); the theme itself is on."
    ok "Vapor theme active."
 }
 taskbar_drop_discover() {
    # Plasma's default taskbar pins Discover, which CachyOS doesn't install: the pin shows as a
    # blank icon. Pin what CachyOS's own layout pins (/etc/skel) instead. Not when Discover is
    # installed, and only on a taskbar that still has the default pins (no launchers key).
    # Edit only while plasmashell is stopped.
    [[ -e /usr/share/applications/org.kde.discover.desktop ]] && return 0
    local applet grp
    for applet in $(plasma_applets org.kde.plasma.icontasks); do
        grp="Containments|${applet%%:*}|Applets|${applet#*:}|Configuration|General"
        [[ -n "$(kreadconfig6 --file plasma-org.kde.plasma.desktop-appletsrc --group Containments --group "${applet%%:*}" \
            --group Applets --group "${applet#*:}" --group Configuration --group General --key launchers)" ]] && continue
        kset theme plasma-org.kde.plasma.desktop-appletsrc "$grp" launchers \
            'applications:systemsettings.desktop,preferred://filemanager,preferred://browser'
    done
 }
 theme_disable() {
    extras_disable
    info "Restoring the previous desktop look and layout..."
@@ -44,13 +44,6 @@ vram_nvidia() {
 # 470xx, 390xx); every other NVIDIA card runs the open kernel modules.
 VRAM_CHWD_IDS=/var/lib/chwd/ids
 vram_nvidia_legacy_id() {
    # vram_nvidia_legacy_id <pci device id, with or without 0x>: 0 when chwd
    # lists the card for a closed legacy branch, i.e. it is older than the
    # RTX 20 series. Also what lib/nvidia.sh uses to decide if a card is supported.
    grep -qwi "${1#0x}" "$VRAM_CHWD_IDS"/nvidia-*.ids 2>/dev/null
 }
 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>"
@@ -69,7 +62,8 @@ vram_nvidia_case() {
    esac
    for d in /sys/bus/pci/devices/*; do
        [[ "$(cat "$d/vendor" 2>/dev/null)" == 0x10de && "$(cat "$d/class" 2>/dev/null)" == 0x03* ]] || continue
-        vram_nvidia_legacy_id "$(cat "$d/device")" && { echo legacy; return; }
+        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; }
@@ -14,9 +14,4 @@ read and reviewed on their own. `lib/*.sh` reads them with `patch_file
 | `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 |
 | `steamify-os-release.sh`, `steamify-os-release.hook` | `lib/login-manager.sh` (SteamOS conversion) | What Steam's System settings show besides the OS name (which stays CachyOS's): `VERSION_ID=steamos-X.Y`, `VERSION_CODENAME=steam-machine`, `VARIANT`/`VARIANT_ID` Steamify with its version, in `/etc/os-release`; the pacman hook runs it again after cachyos-hooks (`fill SCRIPT=... VERSION=... STEAMOS=...`) |
 | `steamify-nvidia-initramfs.sh`, `steamify-nvidia-initramfs.hook` | `lib/nvidia.sh` (SteamOS conversion, NVIDIA fix) | The pacman hook (before the initramfs is built, after DKMS) and its script: the NVIDIA modules go into the initramfs only while every installed kernel has them, decided again at every kernel or driver change (`fill SCRIPT=...`) |
 | `cros-ec-cec-single-port.patch` | `lib/cec.sh` (HDMI-CEC) | Makes Valve's Steam Machine CEC driver find amdgpu's HDMI port |
 | `gamescope-gbm-scanout.patch` | `lib/gamescope-nvidia.sh` (gamescope on NVIDIA) | gamescope 3.16.31 patch: scan-out buffers allocated with GBM (opt-in, `gamescope_drm_gbm_scanout=1`), which cures the corrupted picture on NVIDIA; from farnoy/gamescope, see the header of the file |
 | `gamescope-nvidia.PKGBUILD` | `lib/gamescope-nvidia.sh` (gamescope on NVIDIA) | The recipe for the patched gamescope package (`steamify-gamescope-nvidia`, provides and conflicts with `gamescope`): Valve's gamescope at `pkgver` plus `gamescope-gbm-scanout.patch`; written with the patch to a temporary folder and built with `makepkg` |
 | `cros-ec-cec.c` | `lib/cec.sh` (HDMI-CEC) | Valve's Steam Machine CEC driver (GPL-2.0+, from evlaV/linux-integration at the pinned commit): the backup when downloading it from GitHub fails; used only if its sha256 equals `CEC_DRIVER_SHA256` (a new pin needs a new copy) |
 | `python-hid-shim.PKGBUILD` | `lib/packages.sh` (required packages) | An empty package that provides `python-hid`, for PCs that keep `python-hidapi` (they conflict; jupiter-hw-support, a dependency of gamescope-session-cachyos, wants python-hid, only the Steam Deck controller updater uses it): built with `makepkg` and installed before the conversion's packages |
@@ -1,621 +0,0 @@
 // SPDX-License-Identifier: GPL-2.0+
 /*
 * CEC driver for ChromeOS Embedded Controller
 *
 * Copyright (c) 2018 BayLibre, SAS
 * Author: Neil Armstrong <narmstrong@baylibre.com>
 */
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/mod_devicetable.h>
 #include <linux/platform_device.h>
 #include <linux/dmi.h>
 #include <linux/pci.h>
 #include <linux/cec.h>
 #include <linux/slab.h>
 #include <linux/interrupt.h>
 #include <linux/platform_data/cros_ec_commands.h>
 #include <linux/platform_data/cros_ec_proto.h>
 #include <media/cec.h>
 #include <media/cec-notifier.h>
 #define DRV_NAME	"cros-ec-cec"
 /**
 * struct cros_ec_cec_port - Driver data for a single EC CEC port
 *
 * @port_num: port number
 * @adap: CEC adapter
 * @notify: CEC notifier pointer
 * @rx_msg: storage for a received message
 * @cros_ec_cec: pointer to the parent struct
 */
 struct cros_ec_cec_port {
 	int port_num;
 	struct cec_adapter *adap;
 	struct cec_notifier *notify;
 	struct cec_msg rx_msg;
 	struct cros_ec_cec *cros_ec_cec;
 };
 /**
 * struct cros_ec_cec - Driver data for EC CEC
 *
 * @cros_ec: Pointer to EC device
 * @notifier: Notifier info for responding to EC events
 * @write_cmd_version: Highest supported version of EC_CMD_CEC_WRITE_MSG.
 * @num_ports: Number of CEC ports
 * @ports: Array of ports
 */
 struct cros_ec_cec {
 	struct cros_ec_device *cros_ec;
 	struct notifier_block notifier;
 	int write_cmd_version;
 	int num_ports;
 	struct cros_ec_cec_port *ports[EC_CEC_MAX_PORTS];
 };
 static void cros_ec_cec_received_message(struct cros_ec_cec_port *port,
 					 uint8_t *msg, uint8_t len)
 {
 	if (len > CEC_MAX_MSG_SIZE)
 		len = CEC_MAX_MSG_SIZE;
 	port->rx_msg.len = len;
 	memcpy(port->rx_msg.msg, msg, len);
 	cec_received_msg(port->adap, &port->rx_msg);
 }
 static void handle_cec_message(struct cros_ec_cec *cros_ec_cec)
 {
 	struct cros_ec_device *cros_ec = cros_ec_cec->cros_ec;
 	uint8_t *cec_message = cros_ec->event_data.data.cec_message;
 	unsigned int len = cros_ec->event_size;
 	struct cros_ec_cec_port *port;
 	/*
 	 * There are two ways of receiving CEC messages:
 	 * 1. Old EC firmware which only supports one port sends the data in a
 	 *    cec_message MKBP event.
 	 * 2. New EC firmware which supports multiple ports uses
 	 *    EC_MKBP_CEC_HAVE_DATA to notify that data is ready and
 	 *    EC_CMD_CEC_READ_MSG to read it.
 	 * Check that the EC only has one CEC port, and then we can assume the
 	 * message is from port 0.
 	 */
 	if (cros_ec_cec->num_ports != 1) {
 		dev_err(cros_ec->dev,
 			"received cec_message on device with %d ports\n",
 			cros_ec_cec->num_ports);
 		return;
 	}
 	port = cros_ec_cec->ports[0];
 	cros_ec_cec_received_message(port, cec_message, len);
 }
 static void cros_ec_cec_read_message(struct cros_ec_cec_port *port)
 {
 	struct cros_ec_device *cros_ec = port->cros_ec_cec->cros_ec;
 	struct ec_params_cec_read params = {
 		.port = port->port_num,
 	};
 	struct ec_response_cec_read response;
 	int ret = 0;
 	int count = 0;
 	/* NOTE read as many messages as we can, return value from cros_ec_cmd
 	 *      here should either equal to the bytes transferred or a negative
 	 *      error code, so as long as we get positive integers we are
 	 *      reading messages!
 	 */
 	do {
 		ret = cros_ec_cmd(cros_ec, 0, EC_CMD_CEC_READ_MSG, &params,
 				  sizeof(params), &response, sizeof(response));
 		if (ret > 0) {
 			++count;
 			cros_ec_cec_received_message(port, response.msg, response.msg_len);
 		}
 	}
 	while (ret > 0);
 	if (ret < 0 && count == 0) {
 		dev_err(cros_ec->dev,
 			"error reading CEC message on EC: %d\n", ret);
 	}
 }
 static void handle_cec_event(struct cros_ec_cec *cros_ec_cec)
 {
 	struct cros_ec_device *cros_ec = cros_ec_cec->cros_ec;
 	uint32_t cec_events = cros_ec->event_data.data.cec_events;
 	uint32_t port_num = EC_MKBP_EVENT_CEC_GET_PORT(cec_events);
 	uint32_t events = EC_MKBP_EVENT_CEC_GET_EVENTS(cec_events);
 	struct cros_ec_cec_port *port;
 	if (port_num >= cros_ec_cec->num_ports) {
 		dev_err(cros_ec->dev,
 			"received CEC event for invalid port %d\n", port_num);
 		return;
 	}
 	port = cros_ec_cec->ports[port_num];
 	if (events & EC_MKBP_CEC_SEND_OK)
 		cec_transmit_attempt_done(port->adap, CEC_TX_STATUS_OK);
 	/* FW takes care of all retries, tell core to avoid more retries */
 	if (events & EC_MKBP_CEC_SEND_FAILED)
 		cec_transmit_attempt_done(port->adap,
 					  CEC_TX_STATUS_MAX_RETRIES |
 					  CEC_TX_STATUS_NACK);
 	if (events & EC_MKBP_CEC_HAVE_DATA)
 		cros_ec_cec_read_message(port);
 }
 static int cros_ec_cec_event(struct notifier_block *nb,
 			     unsigned long queued_during_suspend,
 			     void *_notify)
 {
 	struct cros_ec_cec *cros_ec_cec;
 	struct cros_ec_device *cros_ec;
 	cros_ec_cec = container_of(nb, struct cros_ec_cec, notifier);
 	cros_ec = cros_ec_cec->cros_ec;
 	if (cros_ec->event_data.event_type == EC_MKBP_EVENT_CEC_EVENT) {
 		handle_cec_event(cros_ec_cec);
 		return NOTIFY_OK;
 	}
 	if (cros_ec->event_data.event_type == EC_MKBP_EVENT_CEC_MESSAGE) {
 		handle_cec_message(cros_ec_cec);
 		return NOTIFY_OK;
 	}
 	return NOTIFY_DONE;
 }
 static int cros_ec_cec_set_log_addr(struct cec_adapter *adap, u8 logical_addr)
 {
 	struct cros_ec_cec_port *port = adap->priv;
 	struct cros_ec_cec *cros_ec_cec = port->cros_ec_cec;
 	struct cros_ec_device *cros_ec = cros_ec_cec->cros_ec;
 	struct ec_params_cec_set params = {
 		.cmd = CEC_CMD_LOGICAL_ADDRESS,
 		.port = port->port_num,
 		.val = logical_addr,
 	};
 	int ret;
 	ret = cros_ec_cmd(cros_ec, 0, EC_CMD_CEC_SET, &params, sizeof(params),
 			  NULL, 0);
 	if (ret < 0) {
 		dev_err(cros_ec->dev,
 			"error setting CEC logical address on EC: %d\n", ret);
 		return ret;
 	}
 	return 0;
 }
 static int cros_ec_cec_transmit(struct cec_adapter *adap, u8 attempts,
 				u32 signal_free_time, struct cec_msg *cec_msg)
 {
 	struct cros_ec_cec_port *port = adap->priv;
 	struct cros_ec_cec *cros_ec_cec = port->cros_ec_cec;
 	struct cros_ec_device *cros_ec = cros_ec_cec->cros_ec;
 	struct ec_params_cec_write params;
 	struct ec_params_cec_write_v1 params_v1;
 	int ret;
 	if (cros_ec_cec->write_cmd_version == 0) {
 		memcpy(params.msg, cec_msg->msg, cec_msg->len);
 		ret = cros_ec_cmd(cros_ec, 0, EC_CMD_CEC_WRITE_MSG, &params,
 				  cec_msg->len, NULL, 0);
 	} else {
 		params_v1.port = port->port_num;
 		params_v1.msg_len = cec_msg->len;
 		memcpy(params_v1.msg, cec_msg->msg, cec_msg->len);
 		ret = cros_ec_cmd(cros_ec, cros_ec_cec->write_cmd_version,
 				  EC_CMD_CEC_WRITE_MSG, &params_v1,
 				  sizeof(params_v1), NULL, 0);
 	}
 	if (ret < 0) {
 		dev_err(cros_ec->dev,
 			"error writing CEC msg on EC: %d\n", ret);
 		return ret;
 	}
 	return 0;
 }
 static int cros_ec_cec_adap_enable(struct cec_adapter *adap, bool enable)
 {
 	struct cros_ec_cec_port *port = adap->priv;
 	struct cros_ec_cec *cros_ec_cec = port->cros_ec_cec;
 	struct cros_ec_device *cros_ec = cros_ec_cec->cros_ec;
 	struct ec_params_cec_set params = {
 		.cmd = CEC_CMD_ENABLE,
 		.port = port->port_num,
 		.val = enable,
 	};
 	int ret;
 	ret = cros_ec_cmd(cros_ec, 0, EC_CMD_CEC_SET, &params, sizeof(params),
 			  NULL, 0);
 	if (ret < 0) {
 		dev_err(cros_ec->dev,
 			"error %sabling CEC on EC: %d\n",
 			(enable ? "en" : "dis"), ret);
 		return ret;
 	}
 	return 0;
 }
 static const struct cec_adap_ops cros_ec_cec_ops = {
 	.adap_enable = cros_ec_cec_adap_enable,
 	.adap_log_addr = cros_ec_cec_set_log_addr,
 	.adap_transmit = cros_ec_cec_transmit,
 };
 #ifdef CONFIG_PM_SLEEP
 static int cros_ec_cec_suspend(struct device *dev)
 {
 	struct platform_device *pdev = to_platform_device(dev);
 	struct cros_ec_cec *cros_ec_cec = dev_get_drvdata(&pdev->dev);
 	if (device_may_wakeup(dev))
 		enable_irq_wake(cros_ec_cec->cros_ec->irq);
 	return 0;
 }
 static int cros_ec_cec_resume(struct device *dev)
 {
 	struct platform_device *pdev = to_platform_device(dev);
 	struct cros_ec_cec *cros_ec_cec = dev_get_drvdata(&pdev->dev);
 	if (device_may_wakeup(dev))
 		disable_irq_wake(cros_ec_cec->cros_ec->irq);
 	return 0;
 }
 #endif
 static SIMPLE_DEV_PM_OPS(cros_ec_cec_pm_ops,
 	cros_ec_cec_suspend, cros_ec_cec_resume);
 #if IS_ENABLED(CONFIG_PCI) && IS_ENABLED(CONFIG_DMI)
 /*
 * Specify the DRM device name handling the HDMI output and the HDMI connector
 * corresponding to each CEC port. The order of connectors must match the order
 * in the EC (first connector is EC port 0, ...), and the number of connectors
 * must match the number of ports in the EC (which can be queried using the
 * EC_CMD_CEC_PORT_COUNT host command).
 */
 struct cec_dmi_match {
 	const char *sys_vendor;
 	const char *product_name;
 	const char *devname;
 	const char *const *conns;
 };
 static const char *const port_b_conns[] = { "Port B", NULL };
 static const char *const port_c_conns[] = { "Port C", NULL };
 static const char *const port_db_conns[] = { "Port D", "Port B", NULL };
 static const char *const port_ba_conns[] = { "Port B", "Port A", NULL };
 static const char *const port_ab_conns[] = { "Port A", "Port B", NULL };
 static const char *const port_d_conns[] = { "Port D", NULL };
 static const struct cec_dmi_match cec_dmi_match_table[] = {
 	/* AMD Lilac */
 	{ "AMD", "Lilac", "0000:03:00.0", port_c_conns },
 	/* Valve Fremont */
 	{ "OEM", "F7F", "0000:03:00.0", port_c_conns },
 	{ "Valve", "Fremont", "0000:03:00.0", port_c_conns },
 	/* Google Fizz */
 	{ "Google", "Fizz", "0000:00:02.0", port_b_conns },
 	/* Google Brask */
 	{ "Google", "Brask", "0000:00:02.0", port_b_conns },
 	/* Google Moli */
 	{ "Google", "Moli", "0000:00:02.0", port_b_conns },
 	/* Google Kinox */
 	{ "Google", "Kinox", "0000:00:02.0", port_b_conns },
 	/* Google Kuldax */
 	{ "Google", "Kuldax", "0000:00:02.0", port_b_conns },
 	/* Google Aurash */
 	{ "Google", "Aurash", "0000:00:02.0", port_b_conns },
 	/* Google Gladios */
 	{ "Google", "Gladios", "0000:00:02.0", port_b_conns },
 	/* Google Lisbon */
 	{ "Google", "Lisbon", "0000:00:02.0", port_b_conns },
 	/* Google Dibbi */
 	{ "Google", "Dibbi", "0000:00:02.0", port_db_conns },
 	/* Google Constitution */
 	{ "Google", "Constitution", "0000:00:02.0", port_ba_conns },
 	/* Google Boxy */
 	{ "Google", "Boxy", "0000:00:02.0", port_d_conns },
 	/* Google Taranza */
 	{ "Google", "Taranza", "0000:00:02.0", port_db_conns },
 	/* Google Dexi */
 	{ "Google", "Dexi", "0000:00:02.0", port_db_conns },
 	/* Google Dita */
 	{ "Google", "Dita", "0000:00:02.0", port_db_conns },
 	/* Google Dirks */
 	{ "Google", "Dirks", "0000:00:02.0", port_ab_conns },
 	/* Google Moxie */
 	{ "Google", "Moxie", "0000:00:02.0", port_b_conns },
 	/* AMD Lilac */
 	{ "AMD", "Lilac", "0000:06:00.0", port_c_conns },
 };
 static struct device *cros_ec_cec_find_hdmi_dev(struct device *dev,
 						const char * const **conns)
 {
 	int i;
 	for (i = 0 ; i < ARRAY_SIZE(cec_dmi_match_table) ; ++i) {
 		const struct cec_dmi_match *m = &cec_dmi_match_table[i];
 		if (dmi_match(DMI_SYS_VENDOR, m->sys_vendor) &&
 		    dmi_match(DMI_PRODUCT_NAME, m->product_name)) {
 			struct device *d;
 			/* Find the device, bail out if not yet registered */
 			d = bus_find_device_by_name(&pci_bus_type, NULL,
 						    m->devname);
 			if (!d)
 				return ERR_PTR(-EPROBE_DEFER);
 			put_device(d);
 			*conns = m->conns;
 			return d;
 		}
 	}
 	/* Hardware support must be added in the cec_dmi_match_table */
 	dev_warn(dev, "CEC notifier not configured for this hardware\n");
 	return ERR_PTR(-ENODEV);
 }
 #else
 static struct device *cros_ec_cec_find_hdmi_dev(struct device *dev,
 						const char * const **conns)
 {
 	return ERR_PTR(-ENODEV);
 }
 #endif
 static int cros_ec_cec_get_num_ports(struct cros_ec_cec *cros_ec_cec)
 {
 	struct ec_response_cec_port_count response;
 	int ret;
 	ret = cros_ec_cmd(cros_ec_cec->cros_ec, 0, EC_CMD_CEC_PORT_COUNT, NULL,
 			  0, &response, sizeof(response));
 	if (ret < 0) {
 		/*
 		 * Old EC firmware only supports one port and does not support
 		 * the port count command, so fall back to assuming one port.
 		 */
 		cros_ec_cec->num_ports = 1;
 		return 0;
 	}
 	if (response.port_count == 0) {
 		dev_err(cros_ec_cec->cros_ec->dev,
 			"EC reports 0 CEC ports\n");
 		return -ENODEV;
 	}
 	if (response.port_count > EC_CEC_MAX_PORTS) {
 		dev_err(cros_ec_cec->cros_ec->dev,
 			"EC reports too many ports: %d\n", response.port_count);
 		return -EINVAL;
 	}
 	cros_ec_cec->num_ports = response.port_count;
 	return 0;
 }
 static int cros_ec_cec_get_write_cmd_version(struct cros_ec_cec *cros_ec_cec)
 {
 	struct cros_ec_device *cros_ec = cros_ec_cec->cros_ec;
 	struct ec_params_get_cmd_versions_v1 params = {
 		.cmd = EC_CMD_CEC_WRITE_MSG,
 	};
 	struct ec_response_get_cmd_versions response;
 	int ret;
 	ret = cros_ec_cmd(cros_ec, 1, EC_CMD_GET_CMD_VERSIONS, &params,
 			  sizeof(params), &response, sizeof(response));
 	if (ret < 0) {
 		dev_err(cros_ec->dev,
 			"error getting CEC write command version: %d\n", ret);
 		return ret;
 	}
 	if (response.version_mask & EC_VER_MASK(1)) {
 		cros_ec_cec->write_cmd_version = 1;
 	} else {
 		if (cros_ec_cec->num_ports != 1) {
 			dev_err(cros_ec->dev,
 				"v0 write command only supports 1 port, %d reported\n",
 				cros_ec_cec->num_ports);
 			return -EINVAL;
 		}
 		cros_ec_cec->write_cmd_version = 0;
 	}
 	return 0;
 }
 static int cros_ec_cec_init_port(struct device *dev,
 				 struct cros_ec_cec *cros_ec_cec,
 				 int port_num, struct device *hdmi_dev,
 				 const char * const *conns)
 {
 	struct cros_ec_cec_port *port;
 	int ret;
 	port = devm_kzalloc(dev, sizeof(*port), GFP_KERNEL);
 	if (!port)
 		return -ENOMEM;
 	port->cros_ec_cec = cros_ec_cec;
 	port->port_num = port_num;
 	port->adap = cec_allocate_adapter(&cros_ec_cec_ops, port, DRV_NAME,
 					  CEC_CAP_DEFAULTS |
 					  CEC_CAP_CONNECTOR_INFO, 1);
 	if (IS_ERR(port->adap))
 		return PTR_ERR(port->adap);
 	if (!conns[port_num]) {
 		dev_err(dev, "no conn for port %d\n", port_num);
 		ret = -ENODEV;
 		goto out_probe_adapter;
 	}
 	port->notify = cec_notifier_cec_adap_register(hdmi_dev, conns[port_num],
 						      port->adap);
 	if (!port->notify) {
 		ret = -ENOMEM;
 		goto out_probe_adapter;
 	}
 	ret = cec_register_adapter(port->adap, dev);
 	if (ret < 0)
 		goto out_probe_notify;
 	cros_ec_cec->ports[port_num] = port;
 	return 0;
 out_probe_notify:
 	cec_notifier_cec_adap_unregister(port->notify, port->adap);
 out_probe_adapter:
 	cec_delete_adapter(port->adap);
 	return ret;
 }
 static int cros_ec_cec_probe(struct platform_device *pdev)
 {
 	struct cros_ec_dev *ec_dev = dev_get_drvdata(pdev->dev.parent);
 	struct cros_ec_device *cros_ec = ec_dev->ec_dev;
 	struct cros_ec_cec *cros_ec_cec;
 	struct cros_ec_cec_port *port;
 	struct device *hdmi_dev;
 	const char * const *conns = NULL;
 	int ret;
 	hdmi_dev = cros_ec_cec_find_hdmi_dev(&pdev->dev, &conns);
 	if (IS_ERR(hdmi_dev))
 		return PTR_ERR(hdmi_dev);
 	cros_ec_cec = devm_kzalloc(&pdev->dev, sizeof(*cros_ec_cec),
 				   GFP_KERNEL);
 	if (!cros_ec_cec)
 		return -ENOMEM;
 	platform_set_drvdata(pdev, cros_ec_cec);
 	cros_ec_cec->cros_ec = cros_ec;
 	device_init_wakeup(&pdev->dev, 1);
 	ret = cros_ec_cec_get_num_ports(cros_ec_cec);
 	if (ret)
 		return ret;
 	ret = cros_ec_cec_get_write_cmd_version(cros_ec_cec);
 	if (ret)
 		return ret;
 	for (int i = 0; i < cros_ec_cec->num_ports; i++) {
 		ret = cros_ec_cec_init_port(&pdev->dev, cros_ec_cec, i,
 					    hdmi_dev, conns);
 		if (ret)
 			goto unregister_ports;
 	}
 	/* Get CEC events from the EC. */
 	cros_ec_cec->notifier.notifier_call = cros_ec_cec_event;
 	ret = blocking_notifier_chain_register(&cros_ec->event_notifier,
 					       &cros_ec_cec->notifier);
 	if (ret) {
 		dev_err(&pdev->dev, "failed to register notifier\n");
 		goto unregister_ports;
 	}
 	return 0;
 unregister_ports:
 	/*
 	 * Unregister any adapters which have been registered. We don't add the
 	 * port to the array until the adapter has been registered successfully,
 	 * so any non-NULL ports must have been registered.
 	 */
 	for (int i = 0; i < cros_ec_cec->num_ports; i++) {
 		port = cros_ec_cec->ports[i];
 		if (!port)
 			break;
 		cec_notifier_cec_adap_unregister(port->notify, port->adap);
 		cec_unregister_adapter(port->adap);
 	}
 	return ret;
 }
 static void cros_ec_cec_remove(struct platform_device *pdev)
 {
 	struct cros_ec_cec *cros_ec_cec = platform_get_drvdata(pdev);
 	struct device *dev = &pdev->dev;
 	struct cros_ec_cec_port *port;
 	int ret;
 	/*
 	 * blocking_notifier_chain_unregister() only fails if the notifier isn't
 	 * in the list. We know it was added to it by .probe(), so there should
 	 * be no need for error checking. Be cautious and still check.
 	 */
 	ret = blocking_notifier_chain_unregister(
 			&cros_ec_cec->cros_ec->event_notifier,
 			&cros_ec_cec->notifier);
 	if (ret)
 		dev_err(dev, "failed to unregister notifier\n");
 	for (int i = 0; i < cros_ec_cec->num_ports; i++) {
 		port = cros_ec_cec->ports[i];
 		cec_notifier_cec_adap_unregister(port->notify, port->adap);
 		cec_unregister_adapter(port->adap);
 	}
 }
 static const struct platform_device_id cros_ec_cec_id[] = {
 	{ DRV_NAME, 0 },
 	{}
 };
 MODULE_DEVICE_TABLE(platform, cros_ec_cec_id);
 static struct platform_driver cros_ec_cec_driver = {
 	.probe = cros_ec_cec_probe,
 	.remove = cros_ec_cec_remove,
 	.driver = {
 		.name = DRV_NAME,
 		.pm = &cros_ec_cec_pm_ops,
 	},
 	.id_table = cros_ec_cec_id,
 };
 module_platform_driver(cros_ec_cec_driver);
 MODULE_DESCRIPTION("CEC driver for ChromeOS ECs");
 MODULE_AUTHOR("Neil Armstrong <narmstrong@baylibre.com>");
 MODULE_LICENSE("GPL");
@@ -1,124 +0,0 @@
 # Maintainer: theupriser
 # Based on Arch Linux's gamescope PKGBUILD (Maxime Gauduin, Giancarlo Razzolini, Sven-Hendrik Haase and contributors).
 #
 # gamescope with GBM-allocated scan-out buffers for NVIDIA (opt-in: gamescope_drm_gbm_scanout=1).
 # The patch is gamescope-gbm-scanout.patch (next to this file; see its header for where it comes from). pkgver is the gamescope
 # release the patch was made for and tested with. Kept in sync with https://github.com/theupriser/steamify-gamescope-nvidia;
 # Steamify (lib/gamescope-nvidia.sh) writes both files into a temporary folder and runs makepkg there.
 pkgname=steamify-gamescope-nvidia
 _srcname=gamescope
 pkgver=3.16.31
 pkgrel=1
 pkgdesc='SteamOS session compositing window manager, with GBM scan-out for NVIDIA (opt-in: gamescope_drm_gbm_scanout=1)'
 arch=(x86_64)
 url=https://github.com/theupriser/steamify-gamescope-nvidia
 license=(
  BSD-2-Clause
  BSD-3-Clause
  LicenseRef-Reshade
 )
 provides=("gamescope=$pkgver")
 conflicts=(gamescope gamescope-nvidia-gbm)
 replaces=(gamescope-nvidia-gbm)
 depends=(
  glibc
  mesa
  libstdc++
  libgcc
  lcms2
  libavif
  libcap.so
  libdecor
  libdrm
  libei
  libinput
  libpipewire-0.3.so
  libx11
  libxcb
  libxcomposite
  libxcursor
  libxdamage
  libxext
  libxfixes
  libxi
  libxkbcommon.so
  libxmu
  libxrender
  libxres
  libxtst
  libxxf86vm
  luajit
  pixman
  sdl2
  seatd
  systemd-libs
  vulkan-icd-loader
  wayland
  xcb-util-errors
  xcb-util-wm
  xorg-server-xwayland
 )
 makedepends=(
  benchmark
  cmake
  git
  glslang
  meson
  ninja
  vulkan-headers
  wayland-protocols
  catch2
 )
 source=(
  gamescope::git+https://github.com/ValveSoftware/gamescope.git#commit=${pkgver}
  gamescope-gbm-scanout.patch
  git+https://gitlab.freedesktop.org/emersion/libdisplay-info.git
  git+https://gitlab.freedesktop.org/emersion/libliftoff.git
  git+https://github.com/ValveSoftware/openvr.git
  git+https://github.com/Joshua-Ashton/reshade.git
  git+https://github.com/KhronosGroup/SPIRV-Headers.git
  git+https://github.com/Joshua-Ashton/vkroots.git
  git+https://gitlab.freedesktop.org/wlroots/wlroots.git
 )
 b2sums=('SKIP'
        'SKIP'
        'SKIP'
        'SKIP'
        'SKIP'
        'SKIP'
        'SKIP'
        'SKIP'
        'SKIP')
 prepare() {
  cd gamescope
  # GBM scan-out for NVIDIA. If it no longer applies to this gamescope version, stop here: the build must not
  # silently produce an unpatched gamescope under this package's name.
  git apply --check ../gamescope-gbm-scanout.patch || { echo "gbm patch does not apply to gamescope ${pkgver}" >&2; return 1; }
  git apply ../gamescope-gbm-scanout.patch
  meson subprojects download
  for submodule in src/reshade subprojects/{libdisplay-info,libliftoff,openvr,vkroots,wlroots} thirdparty/SPIRV-Headers; do
    git submodule init ${submodule}
    git config submodule.${submodule}.url ../${submodule##*/}
  done
  git -c protocol.file.allow=always submodule update
 }
 build() {
  arch-meson gamescope build \
    -Dforce_fallback_for=glm,stb,libdisplay-info,libliftoff,vkroots \
    -Dpipewire=enabled
  meson compile -C build
 }
 package() {
  DESTDIR="${pkgdir}" meson install -C build \
    --skip-subprojects
  install -Dm 644 gamescope/LICENSE -t "${pkgdir}"/usr/share/licenses/${pkgname}/
 }
 # vim: ts=2 sw=2 et:
@@ -1,17 +0,0 @@
 # Maintainer: theupriser
 # An empty package that only tells pacman "python-hid is there". For a PC that keeps python-hidapi (liquidctl needs it):
 # the real python-hid conflicts with it, and jupiter-hw-support (a dependency of gamescope-session-cachyos) wants python-hid.
 # Only Valve's Steam Deck controller firmware updater in jupiter-hw-support uses it, which a PC doesn't run.
 # Steamify (lib/packages.sh) builds it with makepkg and installs it before the conversion's packages.
 pkgname=steamify-python-hid-shim
 pkgver=1
 pkgrel=1
 pkgdesc='Placeholder: python-hid for PCs that keep python-hidapi (they conflict)'
 arch=(any)
 license=(MIT)
 depends=(python-hidapi)
 provides=('python-hid=99')
 package() {
    :
 }
@@ -7,11 +7,6 @@
 * 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.
 *
 * What it does follows Valve's Steam Machine kernel
 * (https://github.com/evlaV/linux-integration, GPL-2.0 like the rest of the
 * Linux kernel); this module is Steamify's own implementation of it, also
 * GPL-2.0. Not affiliated with or endorsed by Valve Corporation.
 */
 #include <linux/acpi.h>
 #include <linux/bits.h>
@@ -1,17 +0,0 @@
 # Installed by Steamify CachyOS (SteamOS conversion, NVIDIA fix): decides
 # again whether the NVIDIA modules go into the initramfs, after DKMS has built
 # its modules (71-dkms-install) and before the initramfs is built
 # (90-mkinitcpio-install); hooks run in file name order.
 [Trigger]
 Operation = Install
 Operation = Upgrade
 Operation = Remove
 Type = Path
 Target = usr/lib/modules/*/vmlinuz
 Target = usr/lib/modules/*/extramodules/nvidia*
 Target = usr/lib/modules/*/updates/*
 [Action]
 Description = Steamify: NVIDIA modules in the initramfs only if every kernel has them
 When = PostTransaction
 Exec = @SCRIPT@ sync
@@ -1,36 +0,0 @@
 #!/bin/bash
 # Installed by Steamify CachyOS (SteamOS conversion, NVIDIA fix), run by the
 # pacman hook steamify-nvidia-initramfs.hook before the initramfs is built.
 # The NVIDIA modules go into the initramfs (early KMS) only while EVERY
 # installed kernel has them: mkinitcpio fails on a module a kernel lacks, and
 # limine-mkinitcpio then skips that kernel's boot entry, kernel parameters
 # included. Decided again at every kernel or driver change, so a new kernel
 # without the modules (another kernel, a failed DKMS build, a downgrade) gets
 # a working initramfs and the file comes back once it has them.
 #   steamify-nvidia-initramfs [sync|check]
 #   sync   (default) write or remove the drop-in to match
 #   check  exit status 0 when every installed kernel has nvidia_drm
 conf="${NVIDIA_INITRAMFS_CONF:-/etc/mkinitcpio.conf.d/90-steamify-nvidia.conf}"
 mods="${NVIDIA_MODULES_DIR:-/usr/lib/modules}"
 everywhere() {
    local k found=0
    for k in "$mods"/*/; do
        [[ -f "$k/vmlinuz" || -f "$k/pkgbase" ]] || continue   # an installed kernel, not a leftover folder
        find "$k" -name 'nvidia-drm.ko*' -print -quit 2>/dev/null | grep -q . || return 1
        found=1
    done
    [[ $found == 1 ]]
 }
 case "${1:-sync}" in
    check) everywhere ;;
    sync)
        if everywhere; then
            [[ -f "$conf" ]] || { mkdir -p "$(dirname "$conf")" &&
                echo 'MODULES+=(nvidia nvidia_modeset nvidia_uvm nvidia_drm)' > "$conf"; }
        else
            rm -f "$conf"
        fi ;;
    *) echo "usage: $0 [sync|check]" >&2; exit 2 ;;
 esac
@@ -11,6 +11,6 @@ in the shell code.
 |---|---|---|
 | `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` |
-| `steamify-steam-autostart.service` | `lib/nvidia.sh` (Gaming on NVIDIA) | Steam at login on the Plasma desktop, normal or in Big Picture (user unit) |
+| `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) |
@@ -1,13 +1,13 @@
 [Unit]
-Description=Steam at login (Steamify, NVIDIA PCs)
+Description=Steam Background Autostart for Virtual Keyboard
 After=graphical-session.target
 PartOf=graphical-session.target
 [Service]
 Type=simple
-# Only in the Plasma desktop session.
+# Only in the Plasma desktop session; gamescope-session starts its own Steam.
 ExecCondition=/bin/sh -c '[ "$XDG_CURRENT_DESKTOP" = KDE ]'
-ExecStart=/usr/bin/steam @ARGS@
+ExecStart=/usr/bin/steam -silent
 Restart=on-failure
 RestartSec=5
@@ -15,11 +15,11 @@
 set -uo pipefail
 # Release version, see CHANGELOG.md.
-VERSION=2.11.2
+VERSION=2.9.4
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-for lib in common state packages login-manager single-user steam-desktop steam-machine fremont-poweroff vram-booster hdmi-refresh nvidia gamescope-nvidia controllers cec boot-session vapor-theme steamos-extras bios desktop-shortcut wizard-shortcut steam-game update-notifier first-login menu backend; 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 first-login menu backend; do
    # shellcheck source=/dev/null
    source "$SCRIPT_DIR/lib/$lib.sh"
 done
@@ -38,9 +38,7 @@ Item {
    readonly property var status: backend.status || ({})
    readonly property var items: status.items || []
-    // Hidden: Big Picture excludes a silent start.
+    readonly property var rows: items.filter(function (i) { return !i.parent || want[i.parent]; })
    function hidden(i) { return i.id === "nvsilent" && want.bigpicture; }
    readonly property var rows: items.filter(function (i) { return (!i.parent || want[i.parent]) && !hidden(i); })
    readonly property var bios: status.bios || null
    signal passwordRequested()
@@ -65,8 +63,7 @@ Item {
        var w = {};
        for (var i = 0; i < items.length; i++) w[items[i].id] = items[i].kind === "action" ? false : items[i].wanted;
        want = w;
-        // (What the PC has, or what the backend ticked: "Gaming on NVIDIA" moving to the conversion keeps how Steam started.)
+        boot = nowOn("boot") ? "desktop" : "gamescope";
        boot = want.boot ? "desktop" : "gamescope";
        if (sel > rows.length) sel = 0;
    }
    Connections { target: backend; function onStatusChanged() { if (app.screen === "menu" || app.screen === "done") app.syncFromStatus(); } }
@@ -78,15 +75,8 @@ Item {
        var w = Object.assign({}, want);
        w[id] = !w[id];
        // The same rules as the terminal menu (toggle_component).
-        var hasGaming = items.some(function (i) { return i.id === "gaming"; });
+        if (id === "gaming" && !w.gaming) w.single = false;
-        if (id === "gaming" && !w.gaming) { w.single = false; w.silent = false; w.glyphs = false; }
+        if (id === "single" && w.single) w.gaming = true;
        if (id === "single" && w.single && hasGaming) w.gaming = true;
        if (id === "nvidia") w.bigpicture = w.nvidia;
        if (id === "bigpicture" && w.bigpicture) { w.nvidia = true; w.nvsilent = false; }
        if (id === "nvsilent" && w.nvsilent) { w.nvidia = true; w.bigpicture = false; }
        if (id === "nvidia" && !w.nvidia) w.nvsilent = false;
        if (id === "silent" && w.silent) w.gaming = true;
        if (id === "glyphs" && w.glyphs) 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;
@@ -100,10 +90,8 @@ Item {
        for (var i = 0; i < items.length; i++) {
            var it = items[i];
            if (it.kind !== "toggle") continue;
            if (hidden(it)) { if (it.on) p.push({ id: it.id, action: "off" }); continue; }
            if (it.parent && !want[it.parent]) { if (it.on) p.push({ id: it.id, action: "off" }); continue; }
-            // (An item that is off but flagged "update" replaces what the PC has: the conversion for "Gaming on NVIDIA".)
+            if (want[it.id] && !it.on) p.push({ id: it.id, action: "on", isNew: !!it["new"] });
            if (want[it.id] && !it.on) p.push({ id: it.id, action: it.update ? "update" : "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" });
        }
@@ -118,7 +106,7 @@ Item {
    function wantedIds() {
        var ids = [];
        for (var i = 0; i < items.length; i++)
-            if (items[i].kind === "toggle" && want[items[i].id] && !hidden(items[i]) && (!items[i].parent || want[items[i].parent])) ids.push(items[i].id);
+            if (items[i].kind === "toggle" && want[items[i].id] && (!items[i].parent || want[items[i].parent])) ids.push(items[i].id);
        return ids;
    }
@@ -6,22 +6,10 @@ 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"] },
+                  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"] },
        silent: { label: "Start Steam silently in desktop mode", hint: "In the tray at login on the desktop, no window",
                  body: "Steam starts by itself when you log in to the Plasma desktop, in the tray without a window. Gaming mode starts its own Steam.",
                  changes: ["Steam is started with -silent (a systemd user service, desktop only)", "Off: the service is removed again"] },
        nvidia: { label: "Gaming on NVIDIA", hint: "Steam on the desktop, started at login",
                  body: "gamescope's own gaming mode shows a corrupted picture on NVIDIA graphics cards (an open NVIDIA driver bug), so it isn't offered here. This puts Steam on the Plasma desktop instead and starts it when you log in.",
                  changes: ["Steam is installed when it's missing", "Steam starts at login (a systemd user service)", "Off: the service is removed again; Steam is only removed if Steamify installed it"] },
        bigpicture: { label: "Steam starts in Big Picture", hint: "The controller-friendly Steam, or the normal window",
                      body: "Steam opens in Big Picture at login, which works well with a controller on the TV. Untick it for Steam's normal window.",
                      changes: ["Steam is started with -gamepadui", "Plasma starts with an empty session, so old windows don't cover Big Picture", "Off: Steam starts in its normal window"] },
        nvsilent: { label: "Start Steam silently", hint: "In the tray at login, no window",
                    body: "Steam starts in the tray at login without a window. Not together with Big Picture: ticking one unticks the other.",
                    changes: ["Steam is started with -silent", "Off: Steam starts in its normal window"] },
        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"] },
@@ -39,9 +27,6 @@ QtObject {
        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"] },
        extended_controller_support: { label: "Extended controller support", hint: "Xbox wireless dongle, Xbox controllers over Bluetooth",
                  body: "Drivers for Xbox controllers that Linux doesn't handle well by itself. xone makes the Xbox wireless dongle work (the kernel has no driver for it), xpadneo gives an Xbox controller over Bluetooth rumble including the triggers, the right button mapping and its battery level. They are built for every installed kernel, which takes a minute or two each.",
                  changes: ["xone (the dongle) with its firmware, and xpadneo (Bluetooth), from the CachyOS repo", "Kernel headers for every installed kernel, so the drivers build for each", "Off: only what Steamify installed is removed again"] },
        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"] },
		`@@ -1,2 +0,0 @@`
			`Not tested on hardware yet: the whole Steamify flow for the patched gamescope on NVIDIA (apply, reboot, session).`
			`Delete this file when it was, after asking the user (AGENTS.md).`