Steam Frame docs: build, then bring it to the Frame; no game screenshots

The README and both guides start with building the archive from source
(WSL2 on Windows included) and then copying it to the Frame by USB stick or
SSH, since there are no ready-made builds.  The two screenshots of the game
are gone from the README and the repository; the galaxy cover stays.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

ANLEITUNG-STEAM-FRAME.md

@@ -23,51 +23,96 @@ in der [README](README.md).
   europäischen Disc (RMGR01; das Spiel meldet sie als RMGP01). Die
   europäische (RMGP01) und die amerikanische (RMGE01) laufen in der
   Quest-Fassung.
-- Aus den **Releases** dieses Repositorys `GalaxyQuest-SteamFrame-arm64.tar.gz`.
+- Einen **PC** mit Linux oder Windows mit WSL2, um das Programm einmal zu
+  bauen. Einen fertigen Download gibt es nicht.
 
-Einen PC brauchst du nicht: `install.sh` aus dem Archiv entpackt die Disc auf
-der Frame (mit Dolphins `dolphin-tool`; fehlt Dolphin, installiert das Skript
-es aus Flathub), wandelt die Spieldateien um (einige Minuten, 3,3 GB) und
-trägt das Spiel in Steam ein.
+Den Rest macht dann `install.sh` aus dem gebauten Archiv auf der Frame: es
+entpackt die Disc (mit Dolphins `dolphin-tool`; fehlt Dolphin, installiert
+das Skript es aus Flathub), wandelt die Spieldateien um (einige Minuten,
+3,3 GB) und trägt das Spiel in Steam ein.
 
-## 1. Installieren
+## 1. Bauen (PC)
 
-**Variante A – direkt auf der Frame:**
+1. **Nur Windows:** PowerShell öffnen und Ubuntu in WSL2 installieren,
+   dann *Ubuntu 24.04* im Startmenü öffnen und alles Weitere dort:
 
-1. Frame in den Desktop-Modus schalten.
-2. Archiv und Disc-Abbild in den Persönlichen Ordner holen (Download im
-   Browser oder vom USB-Stick kopieren).
-3. Das Archiv dort entpacken (Rechtsklick → *Entpacken → Hierher
-   entpacken*): es entsteht der Ordner `GalaxyQuest`. Nicht auf dem Stick
-   entpacken: dort fehlt dem Programm das Recht, ausgeführt zu werden.
+   ```
+   wsl --install -d Ubuntu-24.04
+   ```
+
+2. Werkzeuge installieren (CMake 3.24+, clang 16+, lld, Ninja; getestet mit
+   clang 20, `sudo apt install clang-20`, falls das Standard-clang
+   scheitert):
+
+   ```
+   sudo apt update
+   sudo apt install git clang lld cmake ninja-build python3 curl
+   ```
+
+3. Valves Steam-Runtime-4-SDK für arm64 herunterladen (etwa 1 GB):
+
+   ```
+   mkdir -p ~/steamrt4-arm64-sdk/sysroot && cd ~/steamrt4-arm64-sdk
+   curl -O https://repo.steampowered.com/steamrt4/images/latest-public-beta/com.valvesoftware.SteamRuntime.Sdk-arm64-steamrt4-sysroot.tar.gz
+   tar -xzf com.valvesoftware.SteamRuntime.Sdk-arm64-steamrt4-sysroot.tar.gz -C sysroot --exclude='./dev/*'
+   ```
+
+4. Quellcode holen und bauen. Im Linux-Heimordner lassen, nicht auf einem
+   Windows-Laufwerk oder USB-Stick (dort fehlt das Recht zum Ausführen):
+
+   ```
+   git clone https://github.com/PodeCaradox/GalaxyQuest-SteamFrame.git ~/GalaxyQuest
+   cd ~/GalaxyQuest
+   ARCH=arm64 STEAMRT4_ARM64_SYSROOT=~/steamrt4-arm64-sdk/sysroot ./build_linux.sh
+   ```
+
+   Ergebnis: `~/GalaxyQuest/build-linux-arm64/GalaxyQuest-SteamFrame-arm64.tar.gz`
+   (beim ersten Mal etwa 10 Minuten; nach `git pull` wird nur Geändertes
+   neu gebaut). Unter Windows öffnet `explorer.exe build-linux-arm64` im
+   Ubuntu-Fenster den Ordner im Explorer.
+
+## 2. Auf die Frame bringen und installieren
+
+**Variante A – USB-Stick, ohne Netzwerk:**
+
+1. `GalaxyQuest-SteamFrame-arm64.tar.gz` und dein Disc-Abbild (hier
+   `smg.iso`) auf einen USB-Stick kopieren.
+2. Frame in den Desktop-Modus schalten, den Stick einstecken.
+3. Im Dateimanager (Dolphin) beide Dateien vom Stick in den Persönlichen
+   Ordner kopieren, dann Rechtsklick auf das Archiv → *Entpacken → Hierher
+   entpacken*: es entsteht der Ordner `GalaxyQuest`. (Nicht auf dem Stick
+   entpacken: dort fehlt dem Programm das Recht, ausgeführt zu werden.)
 4. Konsole öffnen und, mit dem Pfad zu deinem Disc-Abbild:
 
    ```
-   ~/GalaxyQuest/install.sh ~/Downloads/SuperMarioGalaxy.iso
+   ~/GalaxyQuest/install.sh ~/smg.iso
    ```
 
-**Variante B – vom PC über das Netzwerk (SSH):**
+**Variante B – über das Netzwerk (SSH):**
 
-Einmalig auf der Frame: *Einstellungen → System → Entwicklermodus*
-einschalten und in den Entwickler-Einstellungen ein Passwort für den
-Benutzer `steamos` setzen. Damit ist SSH an (`ssh` fragt nach diesem
-Passwort). Ohne Entwicklermodus geht es auch in der Konsole des
-Desktop-Modus: `passwd`, dann `sudo systemctl enable --now sshd`.
+1. Einmalig auf der Frame: *Einstellungen → System → Entwicklermodus*
+   einschalten und in den Entwickler-Einstellungen ein Passwort für den
+   Benutzer `steamos` setzen. Damit ist SSH an. (Ohne Entwicklermodus geht
+   es auch in der Konsole des Desktop-Modus: `passwd`, dann
+   `sudo systemctl enable --now sshd`.)
+2. Auf dem PC (Windows-PowerShell, Linux-Terminal oder das Ubuntu-Fenster),
+   im Ordner mit Archiv und Disc-Abbild:
 
-Dann auf dem PC (Windows-PowerShell oder Linux-Terminal), im Ordner mit dem
-Archiv und dem Disc-Abbild (hier `smg.iso`; `frame.local` geht meistens, sonst
-die IP-Adresse aus `ip a` auf der Frame):
+   ```
+   scp GalaxyQuest-SteamFrame-arm64.tar.gz smg.iso steamos@frame.local:
+   ssh steamos@frame.local "tar -xzf GalaxyQuest-SteamFrame-arm64.tar.gz && ~/GalaxyQuest/install.sh ~/smg.iso && rm ~/smg.iso"
+   ```
 
-```
-scp GalaxyQuest-SteamFrame-arm64.tar.gz smg.iso steamos@frame.local:
-ssh steamos@frame.local "tar -xzf GalaxyQuest-SteamFrame-arm64.tar.gz && ~/GalaxyQuest/install.sh ~/smg.iso && rm ~/smg.iso"
-```
+   Beide fragen nach dem Passwort aus Schritt 1. Wird `frame.local` nicht
+   gefunden (in WSL häufig), die IP-Adresse der Frame nehmen (`ip a` in der
+   Konsole der Frame). Im Ubuntu-Fenster liegt ein Disc-Abbild aus den
+   Windows-Downloads unter `/mnt/c/Users/<du>/Downloads/smg.iso`.
 
-Ohne Prolog- und Abspann-Film (2,3 GB weniger) hinten `--no-movies`
-anhängen. Hast du die Disc schon entpackt (Ordner mit `sys` und `files`),
-geht statt des Abbilds auch dieser Ordner.
+Ohne Prolog- und Abspann-Film (2,3 GB weniger) hinter dem Disc-Abbild
+`--no-movies` anhängen. Hast du die Disc schon entpackt (Ordner mit `sys` und
+`files`), geht statt des Abbilds auch dieser Ordner.
 
-## 2. In Steam einrichten
+## 3. In Steam einrichten
 
 Das Skript trägt das Spiel in Steam ein, wenn Steam läuft (sonst: Steam →
 *Spiele* → *Ein Nicht-Steam-Spiel zur Bibliothek hinzufügen* → *Durchsuchen*
@@ -79,7 +124,7 @@ Eintrags:
 
 Zurück in den VR-Modus wechseln und GalaxyQuest aus der Bibliothek starten.
 
-## 3. Ohne install.sh (von Hand)
+## 4. Ohne install.sh (von Hand)
 
 Auf der Frame gehört das Programm nach `~/GalaxyQuest/`, der *Inhalt* des
 umgewandelten Ordners nach `~/.local/share/GalaxyQuest/game/` (dort direkt
@@ -96,7 +141,7 @@ Findet das Spiel keine Daten im Heimordner, zeigt es beim Start eine Liste
 der Ordner mit Spieldaten (auch auf SD-Karte und USB-Stick); dort einen
 auswählen, das Spiel merkt ihn sich.
 
-## 4. Bildwiederholrate
+## 5. Bildwiederholrate
 
 Das Spiel läuft mit 60 Bildern pro Sekunde und zeigt jedes genau zwei
 Bildwechsel lang, wenn das Headset mit **120 Hz** läuft; beim zweiten dreht
@@ -166,25 +211,9 @@ Hinweis zum Handgelenksriemen beim Start auf Niederländisch).
   Bilder pro Sekunde auf die aktuelle Kopfhaltung nach, was SteamVR selbst
   nicht tut.
 
-## Selbst bauen
+## Entwicklung
 
-Gebaut wird unter Linux oder WSL2 mit **Ubuntu 24.04** (CMake 3.24+,
-clang 16+), gegen Valves Steam-Runtime-4-SDK für arm64:
-
-```
-sudo apt install clang lld cmake ninja-build python3 curl
-mkdir -p ~/steamrt4-arm64-sdk/sysroot && cd ~/steamrt4-arm64-sdk
-curl -O https://repo.steampowered.com/steamrt4/images/latest-public-beta/com.valvesoftware.SteamRuntime.Sdk-arm64-steamrt4-sysroot.tar.gz
-tar -xzf com.valvesoftware.SteamRuntime.Sdk-arm64-steamrt4-sysroot.tar.gz -C sysroot --exclude='./dev/*'
-cd ~/GalaxyQuest        # dieses Repository, nicht auf einem exFAT-Stick
-ARCH=arm64 STEAMRT4_ARM64_SYSROOT=~/steamrt4-arm64-sdk/sysroot ./build_linux.sh
-```
-
-Ergebnis in `build-linux-arm64/`: `galaxyquest`, `libopenxr_loader.so.1`,
-`libjsoncpp.so.26` und daraus gepackt `GalaxyQuest-SteamFrame-arm64.tar.gz`
-(das Release-Archiv, mit `install.sh` aus `platform/linux/` und dem
-Konverter). Ein Entwicklungsstand auf die Frame:
-`tools/push_frame.sh steamos@frame.local [cooked-Ordner]`.
+Ein Entwicklungsstand direkt auf die Frame: `tools/push_frame.sh steamos@frame.local [cooked-Ordner]`.
 
 Was sich gegenüber der Quest-Fassung ändert, steht in
 [docs/TECHNICAL.md](docs/TECHNICAL.md) unter „Steam Frame (Linux)“.

README.md

@@ -10,12 +10,132 @@
 
 # GalaxyQuest
 
-> **Steam Frame:** this is a fork of
-> [bigmak94/GalaxyQuest](https://github.com/bigmak94/GalaxyQuest) that also
-> runs natively on Valve's Steam Frame (SteamOS, arm64). Installation and
-> controls there: [STEAM-FRAME.md](STEAM-FRAME.md) (English),
-> [ANLEITUNG-STEAM-FRAME.md](ANLEITUNG-STEAM-FRAME.md) (Deutsch).
-> Everything below is the original project's README.
+## Steam Frame port
+
+This is a fork of [bigmak94/GalaxyQuest](https://github.com/bigmak94/GalaxyQuest)
+that also runs natively on Valve's **Steam Frame** (SteamOS, arm64).
+How to build and install it is below; controls, settings and
+troubleshooting are in [STEAM-FRAME.md](STEAM-FRAME.md) (English) and
+[ANLEITUNG-STEAM-FRAME.md](ANLEITUNG-STEAM-FRAME.md) (Deutsch).
+
+> **Notice.** This is an unofficial, non-commercial fan project. It is not
+> affiliated with, endorsed by or sponsored by Nintendo. Super Mario Galaxy
+> and all related names are trademarks of Nintendo. This repository contains
+> **no game data** (no disc image, no textures, models, sounds, music or
+> movies) and no ready-made builds. To play you need your own, legally obtained
+> Super Mario Galaxy disc, which you convert yourself. Do not share
+> converted game files, and do not ask for them here.
+>
+> Rights holders who want something removed: please open an issue on this
+> repository, and it will be taken down promptly.
+
+There are no ready-made builds: you build the Frame version yourself on a
+PC (about 10 minutes the first time), copy it to the Frame together with
+your disc image, and run `install.sh` there. `install.sh` extracts the disc
+with Dolphin (installed from Flathub if missing), converts the game files
+and adds the game to Steam.
+
+### 1. Build it (PC)
+
+The Frame version is cross-compiled on a PC running Linux, or Windows with
+WSL2, against Valve's Steam Runtime 4 SDK for arm64.
+
+1. **Windows only:** open PowerShell and install Ubuntu in WSL2, then open
+   *Ubuntu 24.04* from the Start menu and do the rest there:
+
+   ```
+   wsl --install -d Ubuntu-24.04
+   ```
+
+2. Install the tools (CMake 3.24+, clang 16+, lld, Ninja; tested with
+   clang 20, `sudo apt install clang-20` if the default one fails):
+
+   ```
+   sudo apt update
+   sudo apt install git clang lld cmake ninja-build python3 curl
+   ```
+
+3. Download Valve's Steam Runtime 4 SDK sysroot for arm64 (about 1 GB):
+
+   ```
+   mkdir -p ~/steamrt4-arm64-sdk/sysroot && cd ~/steamrt4-arm64-sdk
+   curl -O https://repo.steampowered.com/steamrt4/images/latest-public-beta/com.valvesoftware.SteamRuntime.Sdk-arm64-steamrt4-sysroot.tar.gz
+   tar -xzf com.valvesoftware.SteamRuntime.Sdk-arm64-steamrt4-sysroot.tar.gz -C sysroot --exclude='./dev/*'
+   ```
+
+4. Get the source and build it. Keep it in the Linux home folder, not on a
+   Windows drive or a USB stick (they lose the executable bit):
+
+   ```
+   git clone https://github.com/PodeCaradox/GalaxyQuest-SteamFrame.git ~/GalaxyQuest
+   cd ~/GalaxyQuest
+   ARCH=arm64 STEAMRT4_ARM64_SYSROOT=~/steamrt4-arm64-sdk/sysroot ./build_linux.sh
+   ```
+
+   The result is `~/GalaxyQuest/build-linux-arm64/GalaxyQuest-SteamFrame-arm64.tar.gz`:
+   the program with the OpenXR loader and jsoncpp next to it, `install.sh`,
+   the disc converter and the guides. Later builds (after `git pull`) only
+   rebuild what changed.
+
+   On Windows, `explorer.exe build-linux-arm64` in the Ubuntu window opens
+   that folder in Explorer, to copy the file out.
+
+### 2. Bring it to the Frame and install
+
+**Option A – USB stick, no network setup:**
+
+1. Copy `GalaxyQuest-SteamFrame-arm64.tar.gz` and your disc image (here
+   `smg.iso`) to a USB stick.
+2. On the Frame, switch to desktop mode and plug in the stick.
+3. In the file manager (Dolphin), copy both files from the stick into your
+   home folder, then right-click the archive → *Extract → Extract archive
+   here*. (Not on the stick itself: the program would not be allowed to run
+   from there.)
+4. Open Konsole and run:
+
+   ```
+   ~/GalaxyQuest/install.sh ~/smg.iso
+   ```
+
+**Option B – over the network (SSH):**
+
+1. Once, on the Frame: turn on *Settings → System → Developer Mode* and set
+   a password for the user `steamos` in the developer settings. That turns
+   SSH on.
+2. On the PC, in the folder with the archive and the disc image:
+
+   ```
+   scp GalaxyQuest-SteamFrame-arm64.tar.gz smg.iso steamos@frame.local:
+   ssh steamos@frame.local "tar -xzf GalaxyQuest-SteamFrame-arm64.tar.gz && ~/GalaxyQuest/install.sh ~/smg.iso && rm ~/smg.iso"
+   ```
+
+   Both ask for the password from step 1. If `frame.local` is not found
+   (often the case inside WSL), use the Frame's IP address instead
+   (`ip a` in Konsole on the Frame shows it). From the Ubuntu window the
+   build is at `build-linux-arm64/GalaxyQuest-SteamFrame-arm64.tar.gz` and
+   a disc image in the Windows downloads at
+   `/mnt/c/Users/<you>/Downloads/smg.iso`.
+
+Add `--no-movies` after the disc image to leave out the prologue and ending
+movies (2.3 GB less).
+
+### 3. Start it
+
+`install.sh` adds the game to Steam when Steam is running (otherwise:
+Steam → *Games* → *Add a Non-Steam Game to My Library…* → *Browse* →
+`/home/steamos/GalaxyQuest/galaxyquest`). In the entry's *Properties*,
+rename it to `GalaxyQuest` and **tick "Include in VR Library"**, then start
+it from the library in VR mode.
+
+Controls, settings and troubleshooting: [STEAM-FRAME.md](STEAM-FRAME.md)
+(English), [ANLEITUNG-STEAM-FRAME.md](ANLEITUNG-STEAM-FRAME.md) (Deutsch).
+
+What the port changes compared with the Quest version is described in
+[docs/TECHNICAL.md](docs/TECHNICAL.md) under "Steam Frame (Linux)".
+
+---
+
+*Everything below is the original project's README.*
 
 **Play Super Mario Galaxy in virtual reality, natively on Meta Quest 2 and 3.**
 
@@ -30,8 +150,6 @@ is compiled for the headset's processor. A new platform layer stands in for
 the Wii's hardware (graphics, sound, controllers, saves) and presents the
 game in VR through OpenXR.
 
-![Mario on a pirate ship in the diorama view](docs/images/diorama.jpg)
-
 > **You need your own copy of Super Mario Galaxy.** Neither this repository
 > nor the app contains any game data. You convert your own disc once (its
 > files, and the few pieces of data its program holds), copy the result to
@@ -89,8 +207,6 @@ resolution.
 **Everything else is the original game.** Levels, physics, enemies, music,
 story and saves all come from the game's own code and your own game files.
 
-![The pause menu with the VR settings panel](docs/images/pause_settings.jpg)
-
 ## What you need
 
 - A **Meta Quest 2 or 3** (both tested and working; a Quest 3S should work

STEAM-FRAME.md

@@ -23,50 +23,94 @@ VR settings) is in the [README](README.md).
   Russian fan translation of the European disc (RMGR01; the game reports it
   as RMGP01). The European (RMGP01) and American (RMGE01) discs run in the
   Quest version.
-- `GalaxyQuest-SteamFrame-arm64.tar.gz` from this repository's **Releases**.
+- A **PC** with Linux, or Windows with WSL2, to build the program once.
+  There are no ready-made builds.
 
-You do not need a PC: `install.sh` from the archive extracts the disc on the
-Frame (with Dolphin's `dolphin-tool`; if Dolphin is missing, the script
-installs it from Flathub), converts the game files (a few minutes, 3.3 GB)
-and adds the game to Steam.
+`install.sh` from the built archive then does the rest on the Frame: it
+extracts the disc (with Dolphin's `dolphin-tool`; if Dolphin is missing, the
+script installs it from Flathub), converts the game files (a few minutes,
+3.3 GB) and adds the game to Steam.
 
-## 1. Install
+## 1. Build it (PC)
 
-**Option A – on the Frame itself:**
+1. **Windows only:** open PowerShell and install Ubuntu in WSL2, then open
+   *Ubuntu 24.04* from the Start menu and do the rest there:
 
-1. Switch the Frame to desktop mode.
-2. Put the archive and your disc image into your home folder (download them
-   in the browser or copy them from a USB stick).
-3. Extract the archive there (right-click → *Extract → Extract archive
-   here*): this makes the folder `GalaxyQuest`. Do not extract it on the USB
-   stick: the program would not be allowed to run from there.
+   ```
+   wsl --install -d Ubuntu-24.04
+   ```
+
+2. Install the tools (CMake 3.24+, clang 16+, lld, Ninja; tested with
+   clang 20, `sudo apt install clang-20` if the default one fails):
+
+   ```
+   sudo apt update
+   sudo apt install git clang lld cmake ninja-build python3 curl
+   ```
+
+3. Download Valve's Steam Runtime 4 SDK sysroot for arm64 (about 1 GB):
+
+   ```
+   mkdir -p ~/steamrt4-arm64-sdk/sysroot && cd ~/steamrt4-arm64-sdk
+   curl -O https://repo.steampowered.com/steamrt4/images/latest-public-beta/com.valvesoftware.SteamRuntime.Sdk-arm64-steamrt4-sysroot.tar.gz
+   tar -xzf com.valvesoftware.SteamRuntime.Sdk-arm64-steamrt4-sysroot.tar.gz -C sysroot --exclude='./dev/*'
+   ```
+
+4. Get the source and build it. Keep it in the Linux home folder, not on a
+   Windows drive or a USB stick (they lose the executable bit):
+
+   ```
+   git clone https://github.com/PodeCaradox/GalaxyQuest-SteamFrame.git ~/GalaxyQuest
+   cd ~/GalaxyQuest
+   ARCH=arm64 STEAMRT4_ARM64_SYSROOT=~/steamrt4-arm64-sdk/sysroot ./build_linux.sh
+   ```
+
+   The result is `~/GalaxyQuest/build-linux-arm64/GalaxyQuest-SteamFrame-arm64.tar.gz`
+   (about 10 minutes the first time; after `git pull` only what changed is
+   rebuilt). On Windows, `explorer.exe build-linux-arm64` in the Ubuntu
+   window opens that folder in Explorer.
+
+## 2. Bring it to the Frame and install
+
+**Option A – USB stick, no network setup:**
+
+1. Copy `GalaxyQuest-SteamFrame-arm64.tar.gz` and your disc image (here
+   `smg.iso`) to a USB stick.
+2. On the Frame, switch to desktop mode and plug in the stick.
+3. In the file manager (Dolphin), copy both files from the stick into your
+   home folder, then right-click the archive → *Extract → Extract archive
+   here*. This makes the folder `GalaxyQuest`. (Not on the stick itself:
+   the program would not be allowed to run from there.)
 4. Open Konsole and run, with the path to your disc image:
 
    ```
-   ~/GalaxyQuest/install.sh ~/Downloads/SuperMarioGalaxy.iso
+   ~/GalaxyQuest/install.sh ~/smg.iso
    ```
 
-**Option B – from a PC over the network (SSH):**
+**Option B – over the network (SSH):**
 
-Once, on the Frame: turn on *Settings → System → Developer Mode* and set a
-password for the user `steamos` in the developer settings. That turns SSH on
-(`ssh` asks for this password). Without developer mode, Konsole in desktop
-mode does it too: `passwd`, then `sudo systemctl enable --now sshd`.
+1. Once, on the Frame: turn on *Settings → System → Developer Mode* and set
+   a password for the user `steamos` in the developer settings. That turns
+   SSH on. (Without developer mode, Konsole in desktop mode does it too:
+   `passwd`, then `sudo systemctl enable --now sshd`.)
+2. On the PC (Windows PowerShell, a Linux terminal or the Ubuntu window),
+   in the folder with the archive and the disc image:
 
-Then on the PC (Windows PowerShell or a Linux terminal), in the folder with
-the archive and the disc image (here `smg.iso`; `frame.local` usually works,
-otherwise use the IP address `ip a` shows on the Frame):
+   ```
+   scp GalaxyQuest-SteamFrame-arm64.tar.gz smg.iso steamos@frame.local:
+   ssh steamos@frame.local "tar -xzf GalaxyQuest-SteamFrame-arm64.tar.gz && ~/GalaxyQuest/install.sh ~/smg.iso && rm ~/smg.iso"
+   ```
 
-```
-scp GalaxyQuest-SteamFrame-arm64.tar.gz smg.iso steamos@frame.local:
-ssh steamos@frame.local "tar -xzf GalaxyQuest-SteamFrame-arm64.tar.gz && ~/GalaxyQuest/install.sh ~/smg.iso && rm ~/smg.iso"
-```
+   Both ask for the password from step 1. If `frame.local` is not found
+   (often the case inside WSL), use the Frame's IP address (`ip a` in
+   Konsole on the Frame). From the Ubuntu window a disc image in the
+   Windows downloads is at `/mnt/c/Users/<you>/Downloads/smg.iso`.
 
-Add `--no-movies` at the end to leave out the prologue and ending movies
-(2.3 GB less). If you already extracted the disc (a folder with `sys` and
-`files`), you can give that folder instead of the image.
+Add `--no-movies` after the disc image to leave out the prologue and ending
+movies (2.3 GB less). If you already extracted the disc (a folder with
+`sys` and `files`), you can give that folder instead of the image.
 
-## 2. Set it up in Steam
+## 3. Set it up in Steam
 
 The script adds the game to Steam if Steam is running (otherwise: Steam →
 *Games* → *Add a Non-Steam Game to My Library…* → *Browse* →
@@ -78,7 +122,7 @@ The script adds the game to Steam if Steam is running (otherwise: Steam →
 
 Switch back to VR mode and start GalaxyQuest from the library.
 
-## 3. Without install.sh (by hand)
+## 4. Without install.sh (by hand)
 
 On the Frame the program goes to `~/GalaxyQuest/`, the *contents* of the
 converted folder to `~/.local/share/GalaxyQuest/game/` (with `sys` and
@@ -95,7 +139,7 @@ If the game finds no data in the home folder, it shows a list of folders
 with game data on start (also on SD cards and USB sticks); pick one there
 and the game remembers it.
 
-## 4. Refresh rate
+## 5. Refresh rate
 
 The game runs at 60 frames a second and shows each one for exactly two
 refreshes when the headset runs at **120 Hz**; on the second it turns the
@@ -164,25 +208,9 @@ notice at start is in Dutch on RMGR01).
   120 pictures a second to your current head pose, which SteamVR itself does
   not do.
 
-## Building it yourself
+## Development
 
-Build on Linux or WSL2 with **Ubuntu 24.04** (CMake 3.24+, clang 16+),
-against Valve's Steam Runtime 4 SDK for arm64:
-
-```
-sudo apt install clang lld cmake ninja-build python3 curl
-mkdir -p ~/steamrt4-arm64-sdk/sysroot && cd ~/steamrt4-arm64-sdk
-curl -O https://repo.steampowered.com/steamrt4/images/latest-public-beta/com.valvesoftware.SteamRuntime.Sdk-arm64-steamrt4-sysroot.tar.gz
-tar -xzf com.valvesoftware.SteamRuntime.Sdk-arm64-steamrt4-sysroot.tar.gz -C sysroot --exclude='./dev/*'
-cd ~/GalaxyQuest        # this repository, not on an exFAT stick
-ARCH=arm64 STEAMRT4_ARM64_SYSROOT=~/steamrt4-arm64-sdk/sysroot ./build_linux.sh
-```
-
-The result in `build-linux-arm64/`: `galaxyquest`, `libopenxr_loader.so.1`,
-`libjsoncpp.so.26`, and packed from them
-`GalaxyQuest-SteamFrame-arm64.tar.gz` (the release archive, with
-`install.sh` from `platform/linux/` and the converter). A development build
-to the Frame: `tools/push_frame.sh steamos@frame.local [cooked folder]`.
+A development build straight to the Frame: `tools/push_frame.sh steamos@frame.local [cooked folder]`.
 
 What differs from the Quest version is in
 [docs/TECHNICAL.md](docs/TECHNICAL.md) under "Steam Frame (Linux)".