docs: NVIDIA-INSTRUCTIONS.md: how to test the NVIDIA fix on the real PC, read the results and undo it

Found by running it in a VM: the appended += line became literal text on the
kernel command line, and a kernel without the modules made limine-mkinitcpio
skip its boot entry.

.github/workflows/bundle.yml

@@ -40,12 +40,39 @@ jobs:
       - name: Check
         run: |
           bash -n dist/steamify.sh
-          # SC2034/SC2154: variables used across the inlined modules.
-          shellcheck -S warning -e SC2034,SC2154 dist/steamify.sh
-          shellcheck -S warning dist/steamify-app.sh
           python3 -m py_compile ui/steamify-ui
 
+      # shellcheck through an action that brings its own binary: GitHub's runner has it installed,
+      # Gitea's act_runner image doesn't. One file per run, as before (the exceptions are the bundle's).
+      - name: shellcheck the bundle
+        uses: ludeeus/action-shellcheck@2.0.0
+        env:
+          # SC2034/SC2154: variables used across the inlined modules.
+          SHELLCHECK_OPTS: -e SC2034 -e SC2154
+        with:
+          severity: warning
+          scandir: dist
+          ignore_names: steamify-app.sh
+      - name: shellcheck the app launcher
+        uses: ludeeus/action-shellcheck@2.0.0
+        with:
+          severity: warning
+          scandir: dist
+          ignore_names: steamify.sh
+
+      # The build as an artifact on GitHub and on the mirror (Gitea); releases stay GitHub's.
+      # Gitea's artifact server doesn't speak upload-artifact@v4's protocol, and GitHub fails a workflow
+      # that merely mentions the deprecated @v3: Gitea gets christopherhx's fork of v4 for Gitea.
       - uses: actions/upload-artifact@v4
+        if: github.server_url == 'https://github.com'
+        with:
+          name: steamify
+          path: |
+            dist/steamify.sh
+            dist/steamify-app.tar.gz
+            dist/steamify-app.sh
+      - uses: christopherhx/gitea-upload-artifact@v4
+        if: github.server_url != 'https://github.com'
         with:
           name: steamify
           path: |
@@ -55,6 +82,7 @@ jobs:
 
       - name: Version
         id: version
+        if: github.server_url == 'https://github.com'
         env:
           GH_TOKEN: ${{ github.token }}
         run: |
@@ -69,6 +97,7 @@ jobs:
 
       - name: Publish the v${{ steps.version.outputs.version }} release
         if: >-
+          github.server_url == 'https://github.com' &&
           github.event_name != 'pull_request' && github.ref == 'refs/heads/main' &&
           steps.version.outputs.released == 'false'
         env:
@@ -104,3 +133,85 @@ jobs:
             gh release create latest --title "Steamify CachyOS - latest (v$VERSION)" --notes "$latest_notes" --latest=false
           fi
           gh release upload latest dist/steamify.sh dist/steamify-app.sh dist/steamify-app.tar.gz assets/steam-gaming-settings.svg --clobber
+
+      # The mirror (Gitea) publishes its own release per version too, the same way: never overwrites one,
+      # notes from the changelog. gh can't talk to Gitea: its API for the check, a Gitea release action to
+      # publish. The token is the run's own (repository write); a secret RELEASE_TOKEN overrides it.
+      - name: Version (mirror)
+        id: mirror_version
+        if: github.server_url != 'https://github.com'
+        env:
+          TOKEN: ${{ secrets.RELEASE_TOKEN || github.token }}
+        run: |
+          version="$(grep -oP '^VERSION=\K.*' steamify.sh)"
+          echo "version=$version" >> "$GITHUB_OUTPUT"
+          if curl -fsS -o /dev/null -H "Authorization: token $TOKEN" \
+              "${{ github.server_url }}/api/v1/repos/${{ github.repository }}/releases/tags/v$version"; then
+            echo "released=true" >> "$GITHUB_OUTPUT"
+            echo "::warning::v$version is already released on this server and won't be overwritten."
+          else
+            echo "released=false" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Release notes (mirror)
+        if: >-
+          github.server_url != 'https://github.com' &&
+          github.event_name != 'pull_request' && github.ref == 'refs/heads/main' &&
+          steps.mirror_version.outputs.released == 'false'
+        env:
+          VERSION: ${{ steps.mirror_version.outputs.version }}
+        run: |
+          changes="$(awk -v v="$VERSION" '
+              $0 ~ "^## " { if (found) exit; if (index($0, "## " v " ") == 1) { found = 1; next } }
+              found' CHANGELOG.md)"
+          cat > dist/release-notes.md <<NOTES
+          Single-file build of v$VERSION ($(git describe --always), $(git log -1 --format=%cs)).
+          Run this version with:
+
+              curl -fsSL ${{ github.server_url }}/${{ github.repository }}/releases/download/v$VERSION/steamify.sh | bash
+
+          ## Changes in v$VERSION
+          $changes
+          NOTES
+
+      - name: Publish the v${{ steps.mirror_version.outputs.version }} release (mirror)
+        if: >-
+          github.server_url != 'https://github.com' &&
+          github.event_name != 'pull_request' && github.ref == 'refs/heads/main' &&
+          steps.mirror_version.outputs.released == 'false'
+        uses: akkuman/gitea-release-action@v1.3.7
+        with:
+          token: ${{ secrets.RELEASE_TOKEN || github.token }}
+          tag_name: v${{ steps.mirror_version.outputs.version }}
+          target_commitish: ${{ github.sha }}
+          name: Steamify CachyOS v${{ steps.mirror_version.outputs.version }}
+          body_path: dist/release-notes.md
+          files: |
+            dist/steamify.sh
+            dist/steamify-app.sh
+            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
+      # master) names the ISO after the newest Steamify release, tags it, and the Gitea mirror builds and attaches the ISO.
+      # The branch here decides the kind of build (the workflow's input `kind`):
+      #   main (publishes the release)            -> release: a real ISO (tag v<steamify>-<date>)
+      #   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.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/heads/release/')) &&
+          steps.version.outputs.released == 'false'
+        env:
+          GH_TOKEN: ${{ secrets.ISO_DISPATCH_TOKEN }}
+        run: |
+          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.
+          if [ "$GITHUB_REF" = refs/heads/main ]; then kind=release; sref=""; else kind=dev; sref="$GITHUB_REF_NAME"; fi
+          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})"

.github/workflows/git-upriser-sync.yml

@@ -0,0 +1,26 @@
+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"

.no-release-yet

@@ -0,0 +1,4 @@
+This branch is not ready to be released: do not merge it into the release branch.
+When the feature is complete and tested, ask the user whether it may be released;
+on a yes, delete this file, then open the pull request into the release branch.
+Open work and how to pick it up: TODO-nvidia.md. Research notes: NVIDIA-RESEARCH.md. How to test on the NVIDIA PC: NVIDIA-INSTRUCTIONS.md.

AGENTS.md

@@ -48,6 +48,13 @@ 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`.
+- **Hardware-specific fixes** that belong to a component but aren't a menu
+  row (e.g. `lib/nvidia.sh`: NVIDIA's kernel parameters and early modules
+  for gaming mode, called from `gaming_enable`/`gaming_disable`) detect the
+  hardware themselves, change only what's missing, and undo it on disable.
+  Add them to the source loop in `steamify.sh` and the table in
+  `TECHNICAL.md`. They can't be tested without the hardware: say so in the
+  changelog and 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
@@ -68,6 +75,13 @@ gamescope and the Plasma desktop. Primary target: the Valve Steam Machine
   the entry point's `for lib in ...; do` source loop and wraps everything
   after that loop in `main()`. Keep that loop on one line, keep all logic in
   functions, and don't rely on `SCRIPT_DIR` for anything but sourcing.
+  The workflow is one file for GitHub and a Gitea mirror (`github.server_url`): build and check run on both
+  (shellcheck through `ludeeus/action-shellcheck`, which brings its own binary; the artifact with
+  `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
+  `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,
   so bump `VERSION` for every release.
@@ -119,7 +133,20 @@ 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.
+      or merge to `main`, the user merges that one. Never work directly on
+      `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.
@@ -252,6 +279,11 @@ gamescope and the Plasma desktop. Primary target: the Valve Steam Machine
   kernel only pairs that with a named lookup ("Port C") when the CEC driver
   registered first, which never happens since amdgpu loads from the
   initramfs. Without it `/dev/cec0` exists but stays at `f.f.f.f`.
+  The source comes from one raw.githubusercontent.com download, which GitHub rate-limits (HTTP 429 after a
+  day of test installs, per address): it's kept in `/var/cache/steamify/cros-ec-cec-<sha256:12>.c` and reused
+  while its checksum matches. The name carries the checksum, so a new pin (commit + SHA-256 in `lib/cec.sh`)
+  downloads its own file once and removes the old one. The repo is an unofficial mirror of Valve's kernel
+  without releases: if it ever disappears, ship the file with Steamify. The test VMs share the host's cache.
 - Power-off fix (`poweroff`, `lib/fremont-poweroff.sh`, a default sub-option
   of `machine`): recent kernels (7.2 and the 6.x/7.0/7.1 updates with the
   backport) keep the firmware's S4/S5 wake bit on GPIO
@@ -296,7 +328,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 ([steammachine-cachyos-live-iso](https://github.com/theupriser/steammachine-cachyos-live-iso))
+  Machine ISO ([steamify-cachyos-live-iso](https://github.com/theupriser/steamify-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,

CHANGELOG.md

@@ -5,6 +5,48 @@ 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.9.7 - 2026-10-01
+
+- **feat: the SteamOS conversion fixes a corrupted gaming mode screen with an NVIDIA GPU: nvidia-drm.modeset=1 and fbdev=1 on the kernel command line, NVIDIA modules in the initramfs (lib/nvidia.sh)**
+- **test: tests/nvidia-test.sh runs the NVIDIA fix against a fake RTX 5080 beside an iGPU, a stub modinfo and temp copies of the Limine, systemd-boot and GRUB files (no root, VM or hardware); NVIDIA_DRM_DIR points detection at a fake sysfs tree**
+- **fix: NVIDIA fix on Limine edits the KERNEL_CMDLINE[default] line (an appended += line ended up as literal text on the kernel command line, found in a VM); the modules are only loaded early when every installed kernel has them, and a Limine boot entry without the parameters is an error**
+- **test: tests/nvidia-hardware-test.sh for a real NVIDIA PC: check (read-only state of the detection, the live nvidia_drm modeset/fbdev, versions), apply, and visual (was the gaming mode picture clean), with a report file to paste**
+- **fix: the NVIDIA modules are loaded early only while every installed kernel has them, decided again at every kernel or driver change by a pacman hook (steamify-nvidia-initramfs): a later kernel without the modules (another kernel, a failed DKMS build, a downgrade) no longer makes its initramfs and Limine boot entry fail**
+- **feat: the NVIDIA fix is only for RTX 20 series or newer, decided like the VRAM booster does (vram_nvidia_legacy_id: chwd's legacy card lists); older cards are left alone**
+
+## 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**
+- `b624053` **chore: Version 2.9.4**
+
+## 2.9.3 - 2026-09-29
+
+- `7f5d29c` **feat(ci): a new Steamify release starts the Steamify ISO's release (a test build from the ISO repo's feat/steamify; secret ISO_DISPATCH_TOKEN)**
+- `cfe3ce7` **chore: Version 2.9.3**
+
+## 2.9.2 - 2026-09-29
+
+- **feat(ci): a Gitea mirror publishes its own release per version (akkuman/gitea-release-action; never overwrites one, notes from the changelog, links to the mirror)**
+- **fix(ci): the build also runs on a Gitea mirror (act_runner): shellcheck through ludeeus/action-shellcheck, which brings its own binary; the artifact goes up there with christopherhx/gitea-upload-artifact (GitHub refuses a workflow that mentions the deprecated upload-artifact@v3); releases are only published on GitHub**
+- `fe4f3f4` **chore: Version 2.9.2**
+
 ## 2.9.1 - 2026-09-29
 
 - `c87e6c7` **docs: changelog for the CEC driver cache**

NVIDIA-INSTRUCTIONS.md

@@ -0,0 +1,86 @@
+# Testing the NVIDIA fix on a real PC
+
+For the PC with an RTX 5080 (or any RTX 20 series or newer card) that shows a corrupted picture when
+gaming mode (gamescope) starts. Branch `feature/nvidia-gaming-fix`, not released. Background and open
+work: `TODO-nvidia.md`; research with sources: `NVIDIA-RESEARCH.md`.
+
+## What the fix does
+With a supported NVIDIA GPU (RTX 20 series or newer, same check as the VRAM booster) and its driver installed it
+- adds `nvidia-drm.modeset=1 nvidia-drm.fbdev=1` to the kernel command line (Limine, systemd-boot or GRUB;
+  the file is backed up as `<file>.bak-gamescope-wizard`),
+- loads the NVIDIA modules in the initramfs, but only while every installed kernel has them (a pacman hook,
+  `/etc/pacman.d/hooks/85-steamify-nvidia-initramfs.hook`, decides again at every kernel change),
+- rebuilds the initramfs and boot entries and checks that the parameters really are in them.
+It takes effect after a reboot. Older cards (GTX 10 series and older) are left alone.
+
+## Before you start
+- CachyOS with the NVIDIA driver installed (`nvidia-open`), a user with sudo, `git`.
+- Be at the PC and able to see the screen: the last step needs your eyes.
+- Know the way back (below) in case the PC doesn't boot to a picture: a TTY (Ctrl+Alt+F3) or the boot menu's
+  other kernel entry.
+
+## Steps
+1. Get the code:
+   ```
+   git clone -b feature/nvidia-gaming-fix https://github.com/theupriser/steamify-cachyos
+   cd steamify-cachyos
+   ```
+   (An existing checkout: `git fetch && git checkout feature/nvidia-gaming-fix && git pull`.)
+2. Look first, change nothing:
+   ```
+   bash tests/nvidia-hardware-test.sh check
+   ```
+3. Apply the fix (asks for your sudo password), then **reboot**:
+   ```
+   bash tests/nvidia-hardware-test.sh apply
+   ```
+4. After the reboot, check again:
+   ```
+   bash tests/nvidia-hardware-test.sh check
+   ```
+5. Start gaming mode, look at the screen, then (from the desktop or a TTY):
+   ```
+   bash tests/nvidia-hardware-test.sh visual
+   ```
+   It asks whether the picture was clean and for one line on what you saw.
+6. Send back `~/steamify-nvidia-report.txt` (every run adds to it), or start a new session in the checkout and
+   say "read TODO-nvidia.md and the report".
+
+(`./steamify.sh` from the same checkout also applies the fix, automatically, as part of the SteamOS conversion:
+there is no menu option for it yet. The script above shows more.)
+
+## Reading `check`
+| Line | Good result | If not |
+|---|---|---|
+| `PASS a supported NVIDIA GPU ... is detected` | your 5080 | `FAIL ... older than RTX 20`: the card is skipped on purpose. `FAIL no NVIDIA GPU with its driver`: driver not installed (nouveau?) |
+| `NVIDIA PCI device id 0x... (not on a legacy list ...)` | RTX 20 or newer | on a legacy list: older card |
+| `no chwd legacy lists found` | (note only) | the check cannot tell old from new cards; every card counts as supported. Tell me, it's open item 4 in `TODO-nvidia.md` |
+| `PASS nvidia-drm.modeset=1 is on the running kernel's command line` (and `fbdev=1`) | after step 3 and the reboot | "in the boot loader's file but not booted yet": reboot, or the boot entry used is another one |
+| `PASS nvidia_drm modeset = Y` (and `fbdev = Y`) | after the reboot | `unreadable`: it needs sudo, enter the password |
+| `... early-load drop-in is used / skipped` | note only: skipped means a kernel without the NVIDIA modules is installed | nothing to do |
+
+## Reading the result
+- Parameters on, `modeset = Y`, `fbdev = Y`, picture clean: the fix works.
+- Parameters on and `Y`, picture still corrupted: not this fix. The report has the gamescope and NVIDIA log lines and
+  the versions of `nvidia-open`, `nvidia-utils`, `gamescope` and `gamescope-session-cachyos`: the cause is probably the
+  gamescope/driver combination for Blackwell (see `NVIDIA-RESEARCH.md`).
+- No picture at all after the reboot: undo it (next section) from a TTY or the other kernel entry, and send the report.
+
+## Undo
+Turning the SteamOS conversion off in the wizard removes the fix too. On its own, from the checkout:
+```
+SCRIPT_DIR=$PWD bash -c 'source lib/common.sh; source lib/hdmi-refresh.sh; source lib/vram-booster.sh; source lib/nvidia.sh; nvidia_disable'
+```
+It removes the parameters, the early-load file, the pacman hook and its script, and rebuilds the boot entries (reboot after).
+By hand: delete ` nvidia-drm.modeset=1 nvidia-drm.fbdev=1` from `/etc/default/limine` (`KERNEL_CMDLINE[default]`),
+`/etc/sdboot-manage.conf` (`LINUX_OPTIONS`) or `/etc/default/grub` (`GRUB_CMDLINE_LINUX_DEFAULT`), or restore the
+`.bak-gamescope-wizard` copy next to it; remove `/etc/mkinitcpio.conf.d/90-steamify-nvidia.conf`,
+`/etc/pacman.d/hooks/85-steamify-nvidia-initramfs.hook` and `/usr/local/libexec/steamify-nvidia-initramfs`; then
+`sudo limine-mkinitcpio` (Limine) or `sudo mkinitcpio -P` and `sudo sdboot-manage gen` / `sudo grub-mkconfig -o /boot/grub/grub.cfg`.
+
+## What is and isn't proven
+Proven in VMs (QEMU/KVM, CachyOS ISO 260809): the parameters land and survive a reboot on Limine, systemd-boot and GRUB;
+disabling restores the original; on Limine the pacman hook keeps the early-load file right across kernel reinstalls
+(with fake NVIDIA modules). Not proven: that the fix cures the 5080's picture, the real NVIDIA modules in the
+initramfs, DKMS hook order, systemd-boot/GRUB with a pacman transaction, and the RTX 20+ check against a real chwd list.
+Unit test (no hardware): `bash tests/nvidia-test.sh`.

NVIDIA-RESEARCH.md

@@ -0,0 +1,65 @@
+# NVIDIA and gamescope: research notes (branch `feature/nvidia-gaming-fix`)
+
+Written 2026-10-01 for the NVIDIA fix (`lib/nvidia.sh`). Delete with `TODO-nvidia.md` and
+`.no-release-yet` when the feature is released, or move what is still useful to `TECHNICAL.md`.
+"Verified" means seen in this session (a VM run or a fetched page); the rest is from search results or memory.
+
+## The user's PC
+RTX 5080 (Blackwell). Blackwell only works with NVIDIA's open kernel modules (`nvidia-open`), driver 570+.
+The corrupted picture at gaming mode start is not diagnosed yet: the fix adds kernel parameters, the real cause
+may be the gamescope/driver combination. `tests/nvidia-hardware-test.sh` collects the facts.
+
+## What the fix changes and why (reasoning, not proven for gamescope)
+- gamescope runs the display itself through DRM/KMS. With NVIDIA that needs `nvidia-drm.modeset=1`; `nvidia-drm.fbdev=1`
+  gives the console a framebuffer from `nvidia-drm`, so the hand-off from the console to gamescope is clean.
+- Loading the NVIDIA modules in the initramfs (early KMS) only changes how early boot looks (native resolution,
+  splash, passphrase prompt), not speed. It is not needed for gamescope, which starts after login (believed, not proven).
+- No source found that mentions these parameters for gamescope; the fix is a standard NVIDIA/Wayland setup, applied
+  automatically. Whether it cures the 5080's picture is only known after `tests/nvidia-hardware-test.sh`.
+
+## Which cards (decision 2026-10-01: RTX 20 series or newer only, same check as the VRAM booster)
+The code skips a card whose PCI id is on chwd's legacy lists (`vram_nvidia_legacy_id`); the notes below are why older
+cards are not promised.
+- Open kernel modules: Turing (RTX 20, GTX 16) and newer only; they need the GSP processor first built into Turing.
+  Maxwell, Pascal and Volta (GTX 900/10 series, Titan V) only work with the proprietary driver, whose legacy branch
+  is 580. Source: [NVIDIA README, open kernel modules](https://download.nvidia.com/XFree86/Linux-x86_64/560.35.03/README/kernel_open.html),
+  [NVIDIA datacenter driver guide, kernel modules](https://docs.nvidia.com/datacenter/tesla/driver-installation-guide/kernel-modules.html).
+- `nvidia-drm.modeset` and `fbdev` are options of the `nvidia-drm` module in both flavours, so the fix applies to
+  any card whose driver provides `nvidia_drm` (what `nvidia_present` tests: GPU vendor 0x10de + `modinfo nvidia_drm`).
+  Whether gamescope then works on an older card is a different question, and no source says the fix helps there.
+- Not NVIDIA's proprietary driver: nouveau has no `nvidia_drm`, so the fix does nothing. The CachyOS handheld ISO boots
+  GTX 10xx and older with nouveau until the NVIDIA driver is installed
+  ([CachyOS forum](https://discuss.cachyos.org/t/information-experimental-cachyos-handheld-edition/203)).
+
+## Known gamescope problems that are not this fix
+- **GTX 1050 Ti (Pascal), driver 580.119.02, gamescope newer than 3.16.16:** the CachyOS handheld session fails to start when
+  a display is on the GPU's HDMI port (back to the TTY, loop). Workarounds: downgrade `gamescope` and `lib32-gamescope`
+  to 3.16.16, or use the motherboard's video port. Fixed upstream? unknown.
+  [CachyOS forum](https://discuss.cachyos.org/t/no-display-on-cachyos-handheld-edition-on-nvidia-with-gamescope-3-16-16/20935)
+- **VRS on PCs:** CachyOS' gamescope-session enables variable rate shading (`STEAM_USE_DYNAMIC_VRS=1`,
+  `RADV_FORCE_VRS_CONFIG_FILE`, `echo 1x1 > ...` in `/usr/lib/steamos/gamescope-session`). It broke rendering (missing
+  floors/lighting, bad post-processing) on a PC with an AMD RX 6800 XT. RADV is AMD's driver: not the NVIDIA corruption.
+  Workaround: comment those three lines, or per game `env -u RADV_FORCE_VRS_CONFIG_FILE STEAM_USE_DYNAMIC_VRS=0 %command%`.
+  [CachyOS forum](https://discuss.cachyos.org/t/cachyos-gamescope-session-asset-missing-vrs-fix/34971)
+- gamescope's DRM backend needs Vulkan DRM format modifiers; with the open Mesa driver NVK that came in Mesa 24.1
+  ([GamingOnLinux](https://www.gamingonlinux.com/2024/05/nvk-driver-gets-drm-format-modifiers-to-work-with-gamescope-in-mesa-24-1)).
+  The proprietary driver had format-modifier trouble with gamescope too (GitHub issues
+  [ValveSoftware/gamescope#1662](https://github.com/ValveSoftware/gamescope/issues/1662),
+  [#1516](https://github.com/ValveSoftware/gamescope/issues/1516): titles seen only, not read).
+
+## What was verified in VMs (QEMU/KVM, CachyOS ISO 260809)
+- Kernel parameters land and survive a reboot on Limine, systemd-boot and GRUB; disable restores the original.
+- Limine's tool is a compiled program: an appended `KERNEL_CMDLINE[default]+=" ..."` line was pasted into the kernel
+  command line as text; the fix edits the existing `KERNEL_CMDLINE[default]="..."` line.
+- `mkinitcpio` fails on a MODULES entry a kernel lacks; `limine-mkinitcpio` then skips that kernel's initramfs and boot
+  entry (parameters included); systemd-boot/GRUB image: "may not be complete" (not run with failing modules).
+- Real CachyOS/Limine pacman hooks: `10-limine-snapper-lock`, `60-limine-mkinitcpio-remove-pre`, `60-mkinitcpio-remove`,
+  `80-limine-efi-deploy`, `90-limine-mkinitcpio-remove-post`, `90-mkinitcpio-install`; Steamify's hook is `85-`
+  (DKMS's is `71-dkms-install`, not installed in the VM). A mirror older than the ISO "downgrades" kernels on reinstall.
+- The hook keeps the early-load drop-in right across kernel changes (see `TODO-nvidia.md`).
+
+## Still unknown (needs the hardware)
+- Does the fix cure the 5080's corrupted picture? Which gamescope/driver versions does the PC have?
+- Does it help, harm or do nothing on Maxwell/Pascal/Volta cards? No older card available yet.
+- Real NVIDIA modules in the initramfs (VMs only had renamed fake modules); DKMS hook order on a PC with
+  `nvidia-open-dkms`.

README.md

@@ -94,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/steammachine-cachyos-live-iso)
+[Steamify CachyOS ISO](https://github.com/theupriser/steamify-cachyos-live-iso)
 has Steamify built into the installer: pick the options there, and the
 first boot is already set up.
 

TECHNICAL.md

@@ -206,6 +206,34 @@ 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.
 
+## NVIDIA fix for gaming mode
+
+gamescope drives the display itself through DRM/KMS, which with NVIDIA needs
+kernel modesetting and the framebuffer driver, and the driver loaded early;
+without them gaming mode can show a corrupted image. With a supported NVIDIA GPU (RTX 20 series or newer, decided like the VRAM
+booster does: a card on chwd's legacy lists `/var/lib/chwd/ids/nvidia-*.ids`
+is older and left alone, `vram_nvidia_legacy_id`; without those lists every
+card counts) and its driver installed (`lib/nvidia.sh`), the SteamOS conversion adds
+`nvidia-drm.modeset=1 nvidia-drm.fbdev=1` to the kernel command line (Limine,
+systemd-boot or GRUB; the file is backed up first) and
+`/etc/mkinitcpio.conf.d/90-steamify-nvidia.conf` (`MODULES+=(nvidia
+nvidia_modeset nvidia_uvm nvidia_drm)`), then rebuilds the initramfs and boot
+entries. 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, parameters included). That is decided again
+at every kernel or driver change by a pacman hook
+(`/etc/pacman.d/hooks/85-steamify-nvidia-initramfs.hook`, after DKMS builds,
+before the initramfs is built) running `/usr/local/libexec/steamify-nvidia-initramfs`:
+another kernel without the modules, a failed DKMS build or a downgrade removes
+the drop-in, and it comes back once every kernel has them again.
+On Limine the parameters go into the existing `KERNEL_CMDLINE[default]="..."`
+line: an extra appended `+=` line is pasted into the command line as text.
+Only what's missing is changed; it applies after a reboot. Turning
+the conversion off removes both, the hook and its script. `tests/nvidia-test.sh` tests it against a fake GPU
+and fake boot loader files; `tests/nvidia-hardware-test.sh check|apply|visual` is for a
+real NVIDIA PC (read-only check, the real apply, and a prompt for whether the picture
+was clean), and writes `~/steamify-nvidia-report.txt`.
+
 ## HDMI-CEC
 
 The **HDMI-CEC** item (on every PC; ticked by default only on a Steam
@@ -510,11 +538,12 @@ 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/nvidia.sh` | NVIDIA fix for gaming mode: kernel parameters and early modules (part of the SteamOS conversion) |
 | `lib/vram-booster.sh` | VRAM booster (`dmemcg-booster`, `plasma-foreground-booster`) |
 | `services/` | The systemd units the scripts install (`service_file`, `@KEY@` placeholders); see its README |
 | `patches/` | Module sources and patches the scripts build or apply (`patch_file`); see its README |
 | `.github/tools/bundle.sh` | Builds the single-file version (`dist/steamify.sh`), with `patches/` and `services/` embedded |
-| `.github/workflows/bundle.yml` | Builds and checks it on every push; publishes it on `main` |
+| `.github/workflows/bundle.yml` | Builds and checks it on every push (GitHub and a Gitea mirror); publishes it on `main`, and starts the Steamify ISO's release |
 
 The single-file version is generated: on every push to `main`, GitHub
 Actions runs `.github/tools/bundle.sh`, checks the result with `bash -n` and

TODO-nvidia.md

@@ -0,0 +1,111 @@
+# TODO: NVIDIA fix for gaming mode (branch `feature/nvidia-gaming-fix`)
+
+Delete this file, `NVIDIA-INSTRUCTIONS.md`, `NVIDIA-RESEARCH.md` and `.no-release-yet` when the feature is released.
+Written 2026-10-01 so a new session can pick this up.
+
+## Problem
+A PC with an NVIDIA RTX 5080 (Blackwell, open kernel modules) shows a corrupted
+image when gaming mode (gamescope) starts. Cause not confirmed. Steamify had no
+NVIDIA handling at all. Likely: `nvidia-drm.modeset=1` / `nvidia-drm.fbdev=1`
+missing, or a gamescope/driver mismatch.
+
+## What is built (all on this branch, pushed)
+- `lib/nvidia.sh`: part of the SteamOS conversion (`gaming_enable` / `gaming_disable`).
+  With an NVIDIA GPU + driver it adds `nvidia-drm.modeset=1 nvidia-drm.fbdev=1` to the
+  kernel command line (Limine, systemd-boot, GRUB; backup first) and, only when every
+  installed kernel has `nvidia_drm`, `/etc/mkinitcpio.conf.d/90-steamify-nvidia.conf`.
+  Rebuilds initramfs + boot entries, verifies the config and the generated entries
+  have the parameters (error otherwise). Undone on disable. Description: `TECHNICAL.md`.
+- `FEATURE_VERSION[gaming]=2.9.7` so installs that already have the conversion re-apply it.
+- Test hooks `NVIDIA_DRM_DIR`, `NVIDIA_MODULES_DIR`, `NVIDIA_LIMINE_CONF`,
+  `NVIDIA_SDBOOT_DIR`, `NVIDIA_GRUB_CFG`: only set by tests; defaults are the real paths.
+
+## Tested
+- `bash tests/nvidia-test.sh`: 22 checks against a fake RTX 5080 beside an iGPU, a stub
+  `modinfo`, temp boot loader files. All pass.
+- Real VMs (QEMU/KVM, Limine, systemd-boot, GRUB): enable, reboot, kernel command line
+  has the parameters; disable, reboot, original command line. All pass. Found and fixed:
+  Limine pasted an appended `+=` line as text into the cmdline; a kernel without the
+  NVIDIA modules made limine-mkinitcpio skip its boot entry.
+
+## Kernel changes (done, VM-tested 2026-10-01, Limine)
+The early-load drop-in is kept right by a pacman hook (`patches/steamify-nvidia-initramfs.{sh,hook}`,
+installed by `nvidia_enable`, `/etc/pacman.d/hooks/85-steamify-nvidia-initramfs.hook`). Real pacman
+transactions in a Limine VM: the hook runs between "Updating module dependencies" and "Updating
+linux initcpios" (real hook names there: 60-*-remove, 80-limine-efi-deploy, 90-limine-mkinitcpio-remove-post,
+90-mkinitcpio-install; DKMS would be 71-): the drop-in is present while every kernel has the modules, removed
+when the LTS kernel loses them, back when they return; initramfs nvidia files 1 -> 5 -> 1 -> 5 -> 1
+(1 = baseline, 4 modules added); no ERROR/skipping in any rebuild; cmdline kept the parameters after a reboot;
+disable removes hook, script and drop-in. Found on the way: an empty hook/script was installed when
+`patch_file` failed (now an error). Only tested with fake modules (renamed copies of a small module), on
+Limine; systemd-boot and GRUB use the same hook but were not run with pacman transactions.
+
+## Opt-out toggle (new request, 2026-10-01: not built yet)
+When a compatible NVIDIA card is listed there should be a menu option, on by default (opt-out), named
+"NVIDIA compatibility", as a sub-option of the SteamOS conversion, directly under "Boot into" (`boot`).
+Today the fix runs unconditionally inside `gaming_enable`/`gaming_disable`.
+- [ ] New component `nvidia` in `lib/menu.sh`: `COMPONENTS` right after `boot`, `PARENT[nvidia]=gaming`, `LABEL`,
+      `FEATURE_VERSION[nvidia]`, `component_available` -> `nvidia_available` (= `nvidia_present`); not in
+      `NO_PRESELECT` (ticked by default, `feature_new` ticks it for installs that already have the conversion).
+      `nvidia_status` from the system (hook + parameters present), `nvidia_enable`/`nvidia_disable` = the code now
+      called from `gaming_enable`/`gaming_disable` (remove those calls). Check `toggle_component` dependencies,
+      `feature_record_unticked`, the plan texts ("This will: ...").
+- [ ] The app: `ui/qml/Texts.qml` item texts, `AppState.qml`, the screen rows, `lib/backend.sh` if it lists ids;
+      `--defaults [--options <ids>]` (the Steam Machine ISO's installer pages: it names the ids) and `--skip`.
+- [ ] README rows/screenshot rule (a release that adds a menu row retakes `assets/screenshot-menu.png`), TECHNICAL.md,
+      CHANGELOG, `tests/nvidia-test.sh` (status/enable/disable through the component), VM menu test in
+      steamify-cachyos-dev (`share/vmtest/menu`, TESTPLAN.md row).
+- [x] What "compatible" means (decided 2026-10-01): RTX 20 series or newer, the same check as the VRAM booster
+      (`vram_nvidia_legacy_id`: a card on chwd's legacy lists `/var/lib/chwd/ids/nvidia-*.ids` is older; without the
+      lists every card counts). `nvidia_present` = such a card + `nvidia_drm` available; the toggle's `nvidia_available`
+      is the same function. Older cards (GTX 10/9 series) are left alone: no promise they work with gamescope.
+
+## Older cards and other research
+Decision 2026-10-01: support RTX 20 series or newer only, with the VRAM booster's check (done in `lib/nvidia.sh`).
+The user had hoped older GPUs would work too; not promised. Full notes with sources: **`NVIDIA-RESEARCH.md`**.
+Short version: open kernel modules need Turing+, Maxwell/Pascal/Volta need the proprietary driver (580 legacy branch);
+`nvidia-drm.modeset/fbdev` exist in both, so the fix applies to any card with `nvidia_drm`, but nothing found says gamescope
+works better or worse there (a GTX 1050 Ti has a known gamescope>3.16.16 start problem on HDMI, not ours). Cannot be promised:
+needs a test on a real older card. Design for the toggle: on by default for any card with `nvidia_drm`, the label says
+what it does, `tests/nvidia-hardware-test.sh` reports GPU and driver so results can be compared.
+
+## Still to do
+1. [ ] **On the NVIDIA PC** (only place the real fix can be judged; the full steps, how to read the results and the undo
+   are in `NVIDIA-INSTRUCTIONS.md`), from this checkout:
+   `bash tests/nvidia-hardware-test.sh check` (before), `... apply` (asks sudo), reboot,
+   `... check` (after: `nvidia_drm modeset/fbdev = Y`), boot gaming mode, then
+   `... visual` (was the picture clean?). Everything goes to `~/steamify-nvidia-report.txt`:
+   paste it into the session.
+2. [ ] If the parameters apply but the picture is still corrupted: look at the report's
+   gamescope/NVIDIA log lines and the versions (`nvidia-open`, `nvidia-utils`, `gamescope`,
+   `gamescope-session-cachyos`); the cause is then probably a gamescope/driver mismatch
+   for Blackwell, not this fix.
+3. [ ] Not covered by any test: the early-load drop-in with the REAL NVIDIA modules (the VMs only have renamed
+   fake ones), and systemd-boot/GRUB with a pacman transaction (only Limine was run).
+4. [ ] **Verify the RTX 20+ check on the PC** (decided 2026-10-01, only unit-tested with a fake chwd list; this laptop and the VMs
+   have no `/var/lib/chwd/ids`): `bash tests/nvidia-hardware-test.sh check` prints the NVIDIA PCI id, whether it is on a chwd legacy
+   list, and whether the lists exist at all. Expect for the RTX 5080: "supported", "not on a legacy list". If it says "no chwd
+   legacy lists found" the check cannot tell old from new there (every card then counts as supported, like the VRAM booster):
+   look at what `chwd`/`/var/lib/chwd/ids` provide on CachyOS and whether another source (the open-driver device list, the
+   `nvidia-open` package) would be better for both the VRAM booster and this fix. Also try `check` on any older NVIDIA card
+   that turns up (GTX 10/9 series): it must say "older than RTX 20 ... not applied" and `apply` must change nothing.
+5. [ ] Changelog: fill in the commit hashes of this feature's lines (next commit, per AGENTS.md).
+6. [ ] Build the opt-out toggle (section above) before release.
+7. [ ] When complete and tested: ask the user whether it may be released. On a yes delete
+   `.no-release-yet` and this file, open the PR into `release/2.9.7` (local branch only so
+   far, one commit `chore: Version 2.9.7`; push it then) and merge it. The user merges
+   `release/2.9.7` into `main`.
+
+## Working rules for this repo (see AGENTS.md and ../steamify-cachyos-dev/AGENTS.md)
+- Never work on `main` or a `release/*` branch; no `Co-Authored-By` / "Generated with
+  Claude" lines in commits or PRs. No git identity on the dev laptop: use
+  `git -c user.name="Rick Peters" -c user.email="rickpeters@upriser.nl" commit`.
+- Don't push `release/2.9.7` before the PR (a push can start a dev ISO build).
+
+## If the VM tests need repeating (dev laptop, Ubuntu)
+- `scripts/vminstall.sh` (steamify-cachyos-dev) with `VM_BOOTLOADER=limine|systemd-boot|grub`,
+  `CI=1`, a short `VM_DIR` (`~/vms/...`: socket paths over 108 bytes fail) and `VM_SSH_KEY`.
+- This session's shell lacked the `kvm` group: run QEMU steps as `sg kvm -c "..."`.
+- `/tmp/vminstall-iso.lock` belongs to another user and there is no `bsdtar`: use a copy of
+  `vminstall.sh` with another lock path and a `bsdtar` shim (Python `pycdlib` in a venv).
+- Delete everything afterwards (`~/vms` incl. `pkg-cache`, the 3 GB ISO, keys).

lib/login-manager.sh

@@ -109,6 +109,7 @@ gaming_enable() {
     esac
     create_desktop_shortcut
     steam_enable
+    nvidia_enable || return 1
     os_name_enable || return 1
 }
 
@@ -124,6 +125,7 @@ gaming_disable() {
     steam_disable
     krevert gaming
     os_name_disable
+    nvidia_disable
     ok "The PC boots to the normal login screen again (from the next boot)."
 }
 

lib/menu.sh

@@ -25,7 +25,7 @@ NO_PRESELECT=(boot cec kpin hdmi)
 # FEATURE_BASELINE.
 FEATURE_BASELINE=2.1.0
 declare -A FEATURE_VERSION=(
-    [gaming]=2.9.0 [boot]=2.1.0 [theme]=2.1.0 [glyphs]=2.1.0 [single]=2.1.0
+    [gaming]=2.9.7 [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
     [kpin]=2.1.0 [hdmi]=2.1.0
 )

lib/nvidia.sh

@@ -0,0 +1,165 @@
+#!/bin/bash
+# NVIDIA fix for gaming mode, part of the SteamOS conversion
+# (gaming_enable/gaming_disable). gamescope drives the display itself
+# through DRM/KMS; with NVIDIA that needs kernel modesetting and the
+# framebuffer driver (nvidia-drm.modeset=1 nvidia-drm.fbdev=1) and the
+# driver in the initramfs, or the screen shows a corrupted image.
+# Does nothing without a supported NVIDIA GPU (RTX 20 series or newer) that has
+# its driver installed.
+# Sourced by steamify.sh; not meant to be run on its own.
+
+NVIDIA_PARAMS="nvidia-drm.modeset=1 nvidia-drm.fbdev=1"
+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}
+# The DRM devices in sysfs; the tests point this at a fake tree.
+NVIDIA_DRM_DIR=${NVIDIA_DRM_DIR:-/sys/class/drm}
+
+nvidia_present() {
+    # A supported NVIDIA GPU: PCI vendor 0x10de, display class, its kernel
+    # driver installed, and not older than the RTX 20 series, 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).
+    local f; f="$(nvidia_boot_file)"
+    grep -qw -- "$1" /proc/cmdline 2>/dev/null ||
+        { [[ -n "$f" ]] && grep -qw -- "$1" "$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_enable() {
+    nvidia_present || 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_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
+}

lib/vram-booster.sh

@@ -44,6 +44,13 @@ 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>"
@@ -62,8 +69,7 @@ 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
-        id="$(cat "$d/device")"; id="${id#0x}"
+        vram_nvidia_legacy_id "$(cat "$d/device")" && { echo legacy; return; }
-        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; }

patches/README.md

@@ -14,4 +14,5 @@ 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 |

patches/steamify-nvidia-initramfs.hook

@@ -0,0 +1,17 @@
+# 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

patches/steamify-nvidia-initramfs.sh

@@ -0,0 +1,36 @@
+#!/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

steamify.sh

@@ -15,11 +15,11 @@
 set -uo pipefail
 
 # Release version, see CHANGELOG.md.
-VERSION=2.9.1
+VERSION=2.9.7
 
 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 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 nvidia 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

tests/nvidia-hardware-test.sh

@@ -0,0 +1,93 @@
+#!/bin/bash
+# Test of the NVIDIA fix on a real PC with an NVIDIA GPU (the unit test fakes
+# one: tests/nvidia-test.sh). Run from the Steamify checkout:
+#   bash tests/nvidia-hardware-test.sh check    read-only: what is detected, what the live kernel uses, what apply would change
+#   bash tests/nvidia-hardware-test.sh apply    really applies the fix (sudo), then reboot and run check again
+#   bash tests/nvidia-hardware-test.sh visual   after trying gaming mode: was the picture clean? (asks you)
+# Every run appends to ~/steamify-nvidia-report.txt: paste that file when asking for help.
+cd "$(dirname "$0")/.." || exit 1
+REPORT="${NVIDIA_REPORT:-$HOME/steamify-nvidia-report.txt}"
+source lib/common.sh; source lib/hdmi-refresh.sh; source lib/vram-booster.sh; source lib/nvidia.sh
+mode="${1:-check}"
+fail=0
+say() { echo "$*" | tee -a "$REPORT"; }
+pass() { say "PASS $*"; }
+bad()  { say "FAIL $*"; fail=1; }
+note() { say "     $*"; }
+root_cat() { cat "$1" 2>/dev/null || sudo cat "$1" 2>/dev/null || echo "(unreadable)"; }
+
+say ""; say "===== $(date '+%F %T')  mode=$mode  kernel=$(uname -r)"
+
+report_system() {
+    say "-- GPU and software"
+    lspci -nn 2>/dev/null | grep -iE 'vga|3d|display' | while read -r l; do note "$l"; done
+    command -v nvidia-smi >/dev/null && note "driver: $(nvidia-smi --query-gpu=name,driver_version --format=csv,noheader 2>&1 | head -n 1)"
+    for p in nvidia-open nvidia-utils nvidia-dkms gamescope gamescope-session-cachyos linux-cachyos-nvidia-open; do
+        v="$(pacman -Q "$p" 2>/dev/null)" && note "$v"
+    done
+    note "boot loader file: $(nvidia_boot_file || true)"
+    note "cmdline: $(cat /proc/cmdline)"
+}
+
+check_state() {
+    say "-- Steamify's view"
+    if nvidia_present; then pass "a supported NVIDIA GPU (RTX 20 series or newer) with its driver is detected"
+    elif nvidia_legacy_gpu; then bad "the NVIDIA GPU is older than RTX 20 (on chwd's legacy lists in $VRAM_CHWD_IDS): the fix is not applied"
+    else bad "no NVIDIA GPU with its driver detected: the fix does nothing here"; fi
+    for c in /sys/class/drm/card[0-9]*/device; do
+        [[ "$(cat "$c/vendor" 2>/dev/null)" == 0x10de ]] && note "NVIDIA PCI device id $(cat "$c/device") $(vram_nvidia_legacy_id "$(cat "$c/device")" && echo '(on a chwd legacy list)' || echo '(not on a legacy list: RTX 20 or newer)')"
+    done
+    ls "$VRAM_CHWD_IDS"/nvidia-*.ids >/dev/null 2>&1 || note "no chwd legacy lists found: every NVIDIA card counts as supported"
+    local p
+    for p in $NVIDIA_PARAMS; do
+        if grep -qw -- "$p" /proc/cmdline; then pass "$p is on the running kernel's command line"
+        elif nvidia_param_set "$p"; then bad "$p is in the boot loader's file but not booted yet: reboot"
+        else bad "$p is missing (run: bash tests/nvidia-hardware-test.sh apply)"; fi
+    done
+    say "-- the live NVIDIA driver"
+    local m
+    for m in modeset fbdev; do
+        v="$(root_cat /sys/module/nvidia_drm/parameters/$m)"
+        if [[ "$v" == Y ]]; then pass "nvidia_drm $m = Y"; else bad "nvidia_drm $m = $v (want Y)"; fi
+    done
+    lsmod | grep -q '^nvidia_drm' && pass "nvidia_drm is loaded" || bad "nvidia_drm is not loaded"
+    local c found=0
+    for c in /sys/class/drm/card[0-9]*/device; do
+        [[ "$(cat "$c/vendor" 2>/dev/null)" == 0x10de ]] || continue
+        found=1; note "NVIDIA card: ${c%/device} driver=$(basename "$(readlink -f "$c/driver" 2>/dev/null)")"
+        for s in "${c%/device}"/card*-*/status; do [[ -f "$s" ]] && note "  $(basename "$(dirname "$s")"): $(cat "$s")"; done
+    done
+    [[ $found == 1 ]] || bad "no NVIDIA card in /sys/class/drm"
+    say "-- initramfs"
+    if nvidia_modules_everywhere; then note "every installed kernel has nvidia_drm: the early-load drop-in is used"
+    else note "not every installed kernel has nvidia_drm: the early-load drop-in is skipped (parameters still apply)"; fi
+    nvidia_initramfs_ok && note "NVIDIA modules are in the initramfs config" || note "NVIDIA modules are not in the initramfs config"
+    say "-- what apply would change"
+    if nvidia_params_missing; then note "adds $NVIDIA_PARAMS to $(nvidia_boot_file)"; else note "kernel parameters: nothing to change"; fi
+    if ! nvidia_initramfs_ok && nvidia_modules_everywhere; then note "writes $NVIDIA_INITRAMFS_CONF"; fi
+}
+
+case "$mode" in
+    check)
+        report_system; check_state ;;
+    apply)
+        report_system
+        say "-- applying"
+        if nvidia_enable 2>&1 | tee -a "$REPORT"; [[ ${PIPESTATUS[0]} == 0 ]]; then pass "nvidia_enable finished"
+        else bad "nvidia_enable failed (output above)"; fi
+        say "Now reboot, then run: bash tests/nvidia-hardware-test.sh check" ;;
+    visual)
+        report_system
+        say "-- try gaming mode now (log in to it or reboot into it), look at the screen, then answer"
+        read -rp "Is the gaming mode picture clean (no corruption, no flicker)? [y/n/partly] " a
+        read -rp "What did you see (one line, e.g. 'garbled colours at start, fine after login')? " what
+        say "visual result: $a: $what"
+        [[ "$a" == y ]] && pass "picture clean" || bad "picture not clean ($a)"
+        say "-- gamescope and NVIDIA lines from this boot's log"
+        { journalctl -b --no-pager 2>/dev/null || sudo journalctl -b --no-pager 2>/dev/null; } |
+            grep -iE 'gamescope|nvidia|drm|nvrm|wlserver|vulkan' | tail -n 80 | tee -a "$REPORT" | tail -n 5
+        note "(more in $REPORT)" ;;
+    *) echo "usage: $0 check|apply|visual"; exit 2 ;;
+esac
+say ""; say "Report: $REPORT"
+exit $fail

tests/nvidia-test.sh

@@ -0,0 +1,88 @@
+#!/bin/bash
+# Tests lib/nvidia.sh against a fake RTX 5080 (PCI 10de:2c02) beside an
+# Intel iGPU, a stub modinfo, and temp copies of the boot loader files. No
+# root, VM or NVIDIA hardware needed: bash tests/nvidia-test.sh
+cd "$(dirname "$0")/.." || exit 1
+T="$(mktemp -d)"; trap 'rm -rf "$T"' EXIT
+fail=0
+check() { if eval "$2"; then echo "ok   $1"; else echo "FAIL $1"; fail=1; fi; }
+
+SCRIPT_DIR="$PWD"; source lib/common.sh; source lib/hdmi-refresh.sh; source lib/vram-booster.sh; source lib/nvidia.sh
+sudo() { "$@"; }
+info() { :; }; ok() { :; }; warn() { :; }; err() { echo "ERR $*"; }
+backup_file() { [[ -f "$1.bak" ]] || cp "$1" "$1.bak"; }
+modinfo() { [[ "$FAKE_DRIVER" == 1 ]]; }
+REBUILDS=0; nvidia_rebuild_boot() { REBUILDS=$((REBUILDS + 1)); }
+NVIDIA_INITRAMFS_CONF="$T/90-steamify-nvidia.conf"
+mkdir -p "$T/drm/card0/device" "$T/drm/card1/device"
+echo 0x8086 > "$T/drm/card0/device/vendor"; echo 0x030000 > "$T/drm/card0/device/class"
+echo 0x10de > "$T/drm/card1/device/vendor"; echo 0x030000 > "$T/drm/card1/device/class"
+echo 0x2c02 > "$T/drm/card1/device/device"
+NVIDIA_DRM_DIR="$T/drm"
+mkdir -p "$T/mods/6.1.0-cachyos/kernel"; : > "$T/mods/6.1.0-cachyos/kernel/nvidia-drm.ko.zst"; : > "$T/mods/6.1.0-cachyos/pkgbase"
+NVIDIA_SCRIPT="$T/libexec/steamify-nvidia-initramfs"; NVIDIA_HOOK="$T/hooks/85-steamify-nvidia-initramfs.hook"
+NVIDIA_MODULES_DIR="$T/mods"
+NVIDIA_LIMINE_CONF="$T/none/limine.conf"; NVIDIA_SDBOOT_DIR="$T/none/entries"; NVIDIA_GRUB_CFG="$T/none/grub.cfg"   # not generated here: not checked
+
+mkdir -p "$T/chwd"; VRAM_CHWD_IDS="$T/chwd"
+FAKE_DRIVER=1; check "finds the NVIDIA card as card1 beside an iGPU (no legacy lists)" nvidia_present
+printf '1c03\n1b80\n' > "$T/chwd/nvidia-580.ids"   # a GTX 1060 and a GTX 1080: chwd's 580xx legacy list
+check "RTX 5080 (2c02) is not on a legacy list: supported" nvidia_present
+echo 0x1c03 > "$T/drm/card1/device/device"
+check "GTX 1060 (on chwd's legacy list, older than RTX 20): not supported" '! nvidia_present'
+check "...and reported as a legacy GPU" nvidia_legacy_gpu
+echo 0x2c02 > "$T/drm/card1/device/device"; check "RTX 5080 is not a legacy GPU" '! nvidia_legacy_gpu'
+printf '2c02\n' > "$T/chwd/nvidia-580.ids"; check "a card id that is on a legacy list is skipped, whatever it is" '! nvidia_present'
+printf '1c03\n' > "$T/chwd/nvidia-580.ids"
+FAKE_DRIVER=0; check "skips when the driver isn't installed" '! nvidia_present'
+FAKE_DRIVER=1; NVIDIA_DRM_DIR="$T/none"; check "skips without an NVIDIA GPU" '! nvidia_present'
+NVIDIA_DRM_DIR="$T/drm"
+
+for loader in limine sdboot grub; do
+    case $loader in
+        limine) F="$T/limine"; printf 'KERNEL_CMDLINE[default]="quiet splash"\n' > "$F" ;;
+        sdboot) F="$T/sdboot-manage.conf"; printf 'LINUX_OPTIONS="quiet splash"\n' > "$F" ;;
+        grub)   F="$T/grub";   printf 'GRUB_CMDLINE_LINUX_DEFAULT="quiet splash"\n' > "$F" ;;
+    esac
+    nvidia_boot_file() { echo "$F"; }
+    rm -f "$NVIDIA_INITRAMFS_CONF"; REBUILDS=0; ORIG="$(cat "$F")"
+    nvidia_enable
+    check "$loader: parameters added" 'grep -q "nvidia-drm.modeset=1" "$F" && grep -q "nvidia-drm.fbdev=1" "$F"'
+    check "$loader: initramfs drop-in written" 'grep -q nvidia_drm "$NVIDIA_INITRAMFS_CONF"'
+    check "$loader: script and pacman hook installed" '[[ -x "$NVIDIA_SCRIPT" ]] && grep -q "^Exec = $NVIDIA_SCRIPT sync" "$NVIDIA_HOOK"'
+    check "$loader: backup made, rebuilt once" '[[ -f "$F.bak" && $REBUILDS == 1 ]]'
+    SUM="$(cat "$F")"; nvidia_enable
+    check "$loader: second run changes nothing" '[[ "$(cat "$F")" == "$SUM" && $REBUILDS == 1 ]]'
+    nvidia_disable
+    check "$loader: disable restores the file, drops the drop-in, script and hook" '[[ "$(cat "$F")" == "$ORIG" && ! -f "$NVIDIA_INITRAMFS_CONF" && ! -e "$NVIDIA_SCRIPT" && ! -e "$NVIDIA_HOOK" ]]'
+done
+
+# A missing patches/ file must be an error, never an empty script or hook.
+( SCRIPT_DIR="$T/no-patches"; NVIDIA_SCRIPT="$T/empty/script"; NVIDIA_HOOK="$T/empty/hook"; ! nvidia_hook_install 2>/dev/null && [[ ! -s "$T/empty/script" ]] ) && echo "ok   a missing patch file is an error, nothing empty installed" || { echo "FAIL a missing patch file is an error, nothing empty installed"; fail=1; }
+# The pacman hook's script decides again at every kernel change.
+syncit() { NVIDIA_INITRAMFS_CONF="$NVIDIA_INITRAMFS_CONF" NVIDIA_MODULES_DIR="$NVIDIA_MODULES_DIR" bash "$NVIDIA_SCRIPT" sync; }
+nvidia_hook_install; rm -f "$NVIDIA_INITRAMFS_CONF"
+syncit; check "hook script: every kernel has the modules -> drop-in written" '[[ -f "$NVIDIA_INITRAMFS_CONF" ]]'
+mkdir -p "$T/mods/6.6.0-lts/kernel"; : > "$T/mods/6.6.0-lts/pkgbase"
+syncit; check "hook script: a new kernel without modules -> drop-in removed" '[[ ! -f "$NVIDIA_INITRAMFS_CONF" ]]'
+: > "$T/mods/6.6.0-lts/kernel/nvidia-drm.ko.zst"
+syncit; check "hook script: the modules arrive (DKMS built) -> drop-in back" '[[ -f "$NVIDIA_INITRAMFS_CONF" ]]'
+rm -rf "$T/mods/6.6.0-lts"; mkdir -p "$T/mods/5.0.0-leftover"; : > "$T/mods/5.0.0-leftover/modules.dep"
+syncit; check "hook script: a leftover folder of a removed kernel is ignored" '[[ -f "$NVIDIA_INITRAMFS_CONF" ]]'
+rm -rf "$T/mods/5.0.0-leftover"; nvidia_disable
+# A second kernel without the NVIDIA modules: no early-load drop-in, parameters still set.
+mkdir -p "$T/mods/6.6.0-lts/kernel"; : > "$T/mods/6.6.0-lts/pkgbase"; F="$T/sdboot-manage.conf"; printf 'LINUX_OPTIONS="quiet"\n' > "$F"
+nvidia_boot_file() { echo "$F"; }; rm -f "$NVIDIA_INITRAMFS_CONF"; REBUILDS=0; nvidia_enable
+check "kernel without nvidia modules: no drop-in, parameters set" '[[ ! -f "$NVIDIA_INITRAMFS_CONF" ]] && grep -q "nvidia-drm.fbdev=1" "$F"'
+rm -rf "$T/mods/6.6.0-lts"
+# Generated boot entries without the parameters (the initramfs build failed): an error.
+printf 'linux /vmlinuz root=/dev/sda1\n' > "$T/grub.cfg"; NVIDIA_GRUB_CFG="$T/grub.cfg"
+F="$T/grub"; printf 'GRUB_CMDLINE_LINUX_DEFAULT="quiet"\n' > "$F"; nvidia_boot_file() { echo "$F"; }; rm -f "$NVIDIA_INITRAMFS_CONF"
+check "boot entries without the parameters: error" '! nvidia_enable >/dev/null'
+NVIDIA_GRUB_CFG="$T/none/grub.cfg"
+# A config file without the setting to edit: an error, not "applied".
+F="$T/sdboot-manage.conf"; printf '#LINUX_OPTIONS=""\n' > "$F"; nvidia_boot_file() { echo "$F"; }; REBUILDS=0
+check "no setting to edit: error, nothing rebuilt" '! nvidia_enable >/dev/null && [[ $REBUILDS == 0 ]]'
+FAKE_DRIVER=0; printf 'LINUX_OPTIONS="quiet"\n' > "$T/sdboot"; F="$T/sdboot"; REBUILDS=0; nvidia_enable
+check "no NVIDIA driver: nothing touched" '[[ "$(cat "$F")" == "LINUX_OPTIONS=\"quiet\"" && $REBUILDS == 0 ]]'
+exit $fail