diff --git a/CHANGELOG.md b/CHANGELOG.md
index 03b96b9..97c2ed9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,36 @@ What changed in each SpeedBreaker release, newest first. Each release's notes on
 its entry here, and the game shows the entry once, the first time a new version starts (offline:
 it's built into the game).
 
+## v0.1.9
+
+### What's new
+
+- **Nine more languages** (Settings > Game > Language): French, German, Italian, Spanish, Dutch,
+  Swedish, Danish, Polish and Finnish, from the USA disc's own files. The menus and the race text
+  switch (European languages show km/h) the next time the game starts; the movies and the speech
+  stay in English, as the USA disc has them. English stays the default. Thanks to
+  wendersonrodrigues, who found where the game picks its language (pull request #26).
+- **Fill Screen renders the screen's own shape**, so it's sharper on screens taller than 16:9: a
+  Steam Deck draws 1280x800 at 1x, pixel for pixel, instead of stretching 720 rows to 800. 16:9
+  screens look exactly as before. Thanks to krittinen for the report and the screenshots
+  (issue #34).
+
+### Fixed
+
+- Mac: a wired Xbox One or Series controller can't rumble (macOS takes the rumble and the
+  controller does nothing). The game now says so once: pair it over Bluetooth for rumble.
+
+### More about it
+
+- The line under the Language row says what your installed files give the language you choose.
+  The row isn't shown on iPhone and iPad.
+- SteamOS and Linux: the log names a graphics card's PCIe link and warns when the card reaches
+  the game's memory over PCIe, to help track down slow GPUs (issue #40).
+- `NFSMW_NATIVE_SHAPE=0` keeps the old 16:9-shaped frame for a run, to compare.
+- Updating keeps your saves, settings and the installed game, and needs no disc image: on a Mac,
+  drag the new app into Applications and choose Replace, then Open Anyway once more; on SteamOS,
+  unpack the new download over the old folder.
+
 ## v0.1.8
 
 ### What's new
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8ba9e84..97cf8d3 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -66,7 +66,7 @@ endif()
 # apps' versions, the SteamOS bundles' VERSION file and the release tag
 # (v<version>). CHANGELOG.md has an entry for each version (the in-game
 # "What's new" note is built from it).
-project(SpeedBreaker VERSION 0.1.8 LANGUAGES C CXX)
+project(SpeedBreaker VERSION 0.1.9 LANGUAGES C CXX)
 
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
diff --git a/README.md b/README.md
index 9b35a19..5f81e03 100644
--- a/README.md
+++ b/README.md
@@ -41,7 +41,7 @@
 [Download](#download) · [Quick start](#quick-start) · [How to update](#how-to-update) ·
 [Setup by platform](#setup-by-platform) ·
 [Controls](#controls) · [Settings](#settings) · [Tips](#tips-for-smooth-play) ·
-[FAQ](#faq-and-troubleshooting) · [What's next](#whats-next) ·
+[FAQ](#faq-and-troubleshooting) · [Known issues](#known-issues) · [What's next](#whats-next) ·
 [For developers](#for-developers) · [Credits](#credits) · [License](#license) ·
 [Legal notice](#legal-notice)
 
@@ -64,13 +64,17 @@ and a settings menu you can open mid-race.
   3x is 3840x2160). *Auto* picks a scale for your screen and device.
 - **Ultrawide done right.** On 21:9 screens the view gets wider instead of stretched, and the
   HUD and the rear-view mirror stay in place. A 4:3 iPad, a 3:2 screen or the 16:10 screens of
-  the Steam Deck and many Macs show more above and below instead, and fill the screen.
+  the Steam Deck and many Macs show more above and below instead, and fill the screen at their
+  own resolution: a Steam Deck renders 1280x800 at 1x, pixel for pixel.
 - **Up to 60 fps,** locked to your 60 Hz display. You can also pick a steady 30 at full game
   speed, or *Auto*, which drops to 30 only while a device is hot or can't hold 60. On a Mac with
   a 120 Hz screen, *Smooth Motion* draws up to 120 fps (off by default).
 - **Two-player split screen** (Quick Race > Split Screen), with two controllers.
 - **USB steering wheels (experimental).** Tested with a Logitech G29 on a Mac, force feedback
   included; the steering feel is still being tuned.
+- **Ten languages.** English, French, German, Italian, Spanish, Dutch, Swedish, Danish, Polish
+  and Finnish, from the USA disc's own text (Settings > Game > Language). The movies and the
+  speech stay in English, as on the USA disc.
 - **The sun glare is back.** The low sun glows in open sky and fades behind buildings, as it did
   on the console.
 - **The original look:** sunlit roads and shadows as on the console, the picture a real Xbox 360
@@ -422,7 +426,7 @@ switcher).
 | Frame Rate | Auto / 60 fps / 30 fps | 60 fps on most devices. 30 fps keeps the game at full speed. Auto runs at 60, or at a steady 30 while the device is hot or can't hold 60. |
 | Smooth Motion | On / Off | Off. On a Mac with a 120 Hz screen: up to 120 fps. The game still runs at 60 steps a second, as on the console, and draws one more picture between each two; the controls answer a few milliseconds later. Heavy scenes ease off, down to an even 60 for a while. Takes effect the next time the game starts. Shown only where it works. |
 | Screen Resolution | Full / 75% | Full. iPhone and iPad only: 75% is slightly softer and saves graphics work. |
-| Aspect Ratio | Fill Screen / 16:9 | Fill Screen: wider screens get a wider view; 4:3, 3:2 and 16:10 screens (the Steam Deck, many Macs) a taller one. 16:9 always shows the classic picture with bars. |
+| Aspect Ratio | Fill Screen / 16:9 | Fill Screen: wider screens get a wider view; 4:3, 3:2 and 16:10 screens (the Steam Deck, many Macs) a taller one. Since v0.1.9 the game renders the screen's own shape: a Steam Deck draws 1280x800 at 1x, a 1920x1200 screen 1920x1200 at 1.5x. 16:9 always shows the classic picture with bars. |
 | Brightness | -5 to +5 | 0, the picture as it is. Each step makes the shadows and mid-tones a little lighter or darker, like a TV's brightness; black and white stay put, and the menus never change. |
 | Xbox 360 Display Gamma | On / Off | On: the gamma ramp the game sets for a real Xbox 360's TV output, with slightly deeper shadows and slightly brighter mid-tones. Off: the flatter picture of v0.1.3 and earlier. |
 
@@ -439,7 +443,13 @@ then Yes, puts it back.
 | Sharpening | 0.00 to 1.00 | 0.30 (0 turns it off). With FSR 1, the share of its sharpening pass's full strength. |
 | Anisotropic Filtering | Auto / Off / 2x / 4x / 8x / 16x / Original | Auto: 16x on dedicated graphics cards and M-series iPads, 4x elsewhere. Original uses each texture's own setting, as on the 360. |
 | Mipmaps | On / Off | On, so distant textures don't shimmer |
-| Internal Resolution | Auto / 1x (720p) / 1.5x (1080p) / 2x (1440p) / 3x (2160p) | Auto: enough to cover your screen, within what the device can afford (whole scales only: 1x, 2x, 3x, or 3x2 on an ultrawide). On iPhone and iPad, Auto always picks 1x. |
+| Internal Resolution | Auto / 1x (720p) / 1.5x (1080p) / 2x (1440p) / 3x (2160p) | Auto: enough to cover your screen, within what the device can afford: the screen's own shape when that fits (a Steam Deck's 1280x800), otherwise whole scales (1x, 2x, 3x, or 3x2 on an ultrawide). On iPhone and iPad, Auto always picks 1x. With Fill Screen, the rows count the screen's shape: 1x on a 16:10 screen is 1280x800. |
+
+**Game:** Language (English): French, German, Italian, Spanish, Dutch, Swedish, Danish, Polish or
+Finnish switch the menus and the race text (European languages show km/h) the next time the game
+starts. The text comes from the USA disc's own files; the movies and the speech stay in English.
+The line under the row says what your installed files give the language you choose. Not shown on
+iPhone and iPad.
 
 **Audio:** Master Volume (100%), Mute (Off), and Mute in Background (Off), which silences the
 game while its window isn't in front.
@@ -500,7 +510,8 @@ your own disc, and SpeedBreaker checks it file by file.
 **Which version of the game do I need?**
 The Xbox 360 **USA release (NTSC-U, English)**. The installer checks your image and tells you if
 it's a different version. PAL and Japanese discs and re-releases haven't been tested, so expect
-the installer to refuse them. Games on Demand packages aren't supported, and no title update is
+the installer to refuse them. The USA disc already holds the game's text in nine more languages:
+pick one in Settings > Game > Language. Games on Demand packages aren't supported, and no title update is
 used.
 
 **Does it work with the PC version of the game?**
@@ -594,7 +605,7 @@ SpeedBreaker folder instead: `data/`, `data/game` and `cache/`.
 2. A notice says where the zip file went: your **Desktop** (on SteamOS, pick it up in Desktop
    Mode, or in the Desktop app on a Steam Frame), the **SpeedBreaker** folder in the Files app on
    iPhone and iPad, or the data folder above when there is no Desktop. Its name says which
-   version you were running, for example `speedbreaker-bug-report-v0.1.8-<date>_<time>.zip`.
+   version you were running, for example `speedbreaker-bug-report-v0.1.9-<date>_<time>.zip`.
 3. Open an [issue][issues], attach the zip, and say what you were doing, what you expected, what
    happened, and roughly how long into the session it happened.
 
@@ -604,6 +615,16 @@ crashed, start it again and save a report: the crash report is included. **Never
 files or disc images to an issue.** [CONTRIBUTING.md](CONTRIBUTING.md) says how bug reports and
 pull requests are handled.
 
+## Known issues
+
+- **Mac: wired Xbox controllers don't rumble.** macOS drives an Xbox One or Series controller
+  connected by USB through its own controller framework, which never runs the motors. Pair it
+  over Bluetooth for rumble (a DualSense rumbles either way). The game says so once.
+- **Languages:** the movies and the speech (the police radio, the voices in the scenes) stay in
+  English in every language, as the USA disc has them. Fan translations aren't supported.
+- **Steering wheels are experimental:** the steering feel is still being tuned; see
+  [Settings](#settings).
+
 ## What's next
 
 - **Windows:** coming soon.
diff --git a/runtime/game/language.cpp b/runtime/game/language.cpp
new file mode 100644
index 0000000..cbe5a27
--- /dev/null
+++ b/runtime/game/language.cpp
@@ -0,0 +1,170 @@
+// SpeedBreaker runtime. GPL-3.0-or-later (see COPYING).
+//
+// Settings > Game > Language: the game's text in any of its ten languages,
+// from the USA disc's own files. From wendersonrodrigues's GitHub pull
+// request #26, which found the two constants below.
+//
+// EA built one executable per SKU. The USA one (MWRelease) and Spain's
+// (MWEuropeSpanRelease, default.xex SHA-256 684ceef9...) share the same game
+// code and the same .data; matched function by function, the only
+// differences that touch the disc's files are two constants:
+//
+//   - The boot (sub_823B4740) sets the game's language with
+//     `li r3, <language>; bl sub_822BCBC8` at 0x823B48D8: 0 (English) in the
+//     USA build, 4 (Spanish) in Spain's. That index picks the text
+//     (LANGUAGES\<NAME>.BIN, which the USA disc's archives hold for all ten
+//     languages), the police radio's speech bank
+//     (Sound\Speech\copspeech_<xx>.big for French, German, Italian, Spanish:
+//     the USA disc has only English's) and the movies' language.
+//   - The movie name (sub_82282E80) is "%sMOVIES\%s%s%s%s": prefix, name,
+//     "_<language>", the TV system, ".wmv". The USA build passes "_ntsc"
+//     (0x82078AA8) in r9; Spain's passes "_pal", which the USA build also
+//     holds, unused, at 0x82078AB0. When that language's movie is missing,
+//     the game tries English's with the same suffix.
+//
+// (The rest differs only online: SKU codes, region "NA"/"EU", date format.)
+//
+// Two overrides of the generated, weak functions (no ppc/ regeneration);
+// game/language.h has the decisions:
+//   - sub_822BCBC8, SetCurrentLanguage(r3): on the boot's call r3 becomes
+//     the setting's language (BootLanguage). The debug language cycling's
+//     calls are left alone.
+//   - sub_82282A58, the movie name's sprintf: on sub_82282E80's call r9
+//     becomes "_pal" only when Movies/ holds the chosen language's PAL
+//     movies (MovieSuffix), so with the USA disc's files the game's own
+//     fallback plays the English movies.
+//   - sub_82148818, the attribute lookup: sub_821B82E8's speech record
+//     becomes English's when the chosen language's bank is missing
+//     (SpeechIndex), so the police radio and the in-game scenes' voices play
+//     in English instead of not at all.
+//
+// settings::Id::GameLanguage ([game] language in settings.toml,
+// NFSMW_LANGUAGE=spanish for one run); read at boot, so a change applies at
+// the next launch. English, the default, opens the same files as before.
+#include <stdafx.h>
+#include "language.h"
+
+#include <kernel/function.h>
+#include <user/paths.h>
+#include <user/settings.h>
+
+#include <array>
+#include <filesystem>
+#include <fstream>
+#include <iterator>
+#include <system_error>
+
+extern "C" PPC_FUNC(__imp__sub_822BCBC8);
+extern "C" PPC_FUNC(__imp__sub_82282A58);
+extern "C" PPC_FUNC(__imp__sub_82148818);
+
+namespace
+{
+    using namespace game::language;
+
+    int32_t Chosen()
+    {
+        return settings::GetInt(settings::Id::GameLanguage);
+    }
+
+    // `name` in `dir`, in any case (the disc's folders are "Movies" and
+    // "NFS"; an install on a case-sensitive file system keeps the disc's).
+    std::filesystem::path Child(const std::filesystem::path& dir, std::string_view name)
+    {
+        std::error_code ec;
+        for (const auto& e : std::filesystem::directory_iterator(dir, ec))
+        {
+            const std::string n = e.path().filename().string();
+            if (n.size() == name.size() && EndsWithNoCase(n, name))
+                return e.path();
+        }
+        return {};
+    }
+
+    struct Installed
+    {
+        std::array<Files, std::size(kLanguages)> files;
+    };
+
+    // Read once: Movies/'s names and NFS/ZDIR.BIN (33 KB), never the game's
+    // own file opens.
+    const Installed& InstalledFiles()
+    {
+        static const Installed installed = [] {
+            Installed out;
+            const std::filesystem::path game = GetGamePath();
+            std::vector<std::string> movies;
+            std::error_code ec;
+            if (std::filesystem::path dir = Child(game, "movies"); !dir.empty())
+                for (const auto& e : std::filesystem::directory_iterator(dir, ec))
+                    movies.push_back(e.path().filename().string());
+            std::vector<uint8_t> zdir;
+            if (std::filesystem::path nfs = Child(game, "nfs"); !nfs.empty())
+                if (std::filesystem::path index = Child(nfs, "zdir.bin"); !index.empty())
+                {
+                    std::ifstream f(index, std::ios::binary);
+                    zdir.assign(std::istreambuf_iterator<char>(f), std::istreambuf_iterator<char>());
+                }
+            for (size_t i = 0; i < std::size(kLanguages); i++)
+                out.files[i] = Scan(kLanguages[i], movies, zdir);
+            return out;
+        }();
+        return installed;
+    }
+
+    const Files* FilesOf(int32_t id)
+    {
+        for (size_t i = 0; i < std::size(kLanguages); i++)
+            if (kLanguages[i].id == id)
+                return &InstalledFiles().files[i];
+        return nullptr;
+    }
+}
+
+namespace game::language
+{
+    std::string MenuNote(int32_t id)
+    {
+        const Language* l = Find(id);
+        const Files* f = FilesOf(id);
+        return l && f ? Note(*l, *f) : std::string();
+    }
+}
+
+PPC_FUNC(sub_822BCBC8)
+{
+    if (static_cast<uint32_t>(ctx.lr) == kBootCall)
+    {
+        const int32_t chosen = Chosen();
+        if (const Language* l = Find(chosen))
+            fprintf(stderr, "%s\n", LogLine(*l, *FilesOf(chosen)).c_str());
+        if (const int32_t r3 = BootLanguage(kBootCall, ctx.r3.s32, chosen); r3 != ctx.r3.s32)
+            ctx.r3.s64 = r3;
+    }
+    __imp__sub_822BCBC8(ctx, base);
+}
+
+PPC_FUNC(sub_82282A58)
+{
+    if (static_cast<uint32_t>(ctx.lr) == kMovieNameCall)
+    {
+        const Files* f = FilesOf(Chosen());
+        if (const uint32_t r9 = MovieSuffix(kMovieNameCall, ctx.r9.u32, f && f->pal); r9 != ctx.r9.u32)
+            ctx.r9.u64 = r9;
+    }
+    __imp__sub_82282A58(ctx, base);
+}
+
+// The attribute lookup (852 callers): only sub_821B82E8's speech-record
+// lookups change, and only when the chosen language's bank is missing.
+PPC_FUNC(sub_82148818)
+{
+    const uint32_t lr = static_cast<uint32_t>(ctx.lr);
+    if (lr >= kSpeechPickBegin && lr < kSpeechPickEnd)
+    {
+        const Files* f = FilesOf(Chosen());
+        if (const uint32_t r5 = SpeechIndex(lr, ctx.r4.u32, ctx.r5.u32, f && f->speechToEnglish); r5 != ctx.r5.u32)
+            ctx.r5.u64 = r5;
+    }
+    __imp__sub_82148818(ctx, base);
+}
diff --git a/runtime/game/language.h b/runtime/game/language.h
new file mode 100644
index 0000000..0c42cb0
--- /dev/null
+++ b/runtime/game/language.h
@@ -0,0 +1,225 @@
+// SpeedBreaker runtime. GPL-3.0-or-later (see COPYING).
+//
+// Settings > Game > Language: the decisions game/language.cpp hooks into the
+// game, and what the installed files give each language. Header only, so
+// tests/language_test.cpp checks it without the game.
+//
+// The USA executable fixes its language at boot (`li r3, 0` before the
+// boot's only SetCurrentLanguage call), but the USA disc's archives hold the
+// text of all ten languages in the game's table. Two decisions:
+//   - BootLanguage: the boot's call gets the chosen language; any other
+//     caller, and English everywhere, keep the executable's r3.
+//   - MovieSuffix: the movie name's TV system (`_ntsc` in the USA build)
+//     becomes `_pal` only when Movies/ holds that language's PAL movies and
+//     none of its NTSC ones. Otherwise `_ntsc` stays, the game asks for
+//     <name>_<LANGUAGE>_ntsc.wmv, and its own fallback plays the USA disc's
+//     <name>_ENGLISH_ntsc.wmv: the movies never vanish.
+//   - SpeechIndex: the game picks the police radio's speech record by
+//     language (sub_821B82E8: French, German, Italian and Spanish have their
+//     own, every other language English's). When the chosen language's bank
+//     isn't in the installed files (the USA disc has only English's), the
+//     record lookup is pointed at English's, as the movies fall back, instead
+//     of the game loading nothing at all.
+// Files says what the installed files have for a language (the text pack
+// and the speech bank in NFS/ZDIR.BIN, its movies in Movies/), and Note /
+// LogLine say it in words. Measured with the USA disc's files in Spanish and
+// German (v0.1.9) without the fallback: the game asked for copspeech_sp /
+// _ge, read no speech bank at all and never loaded the in-game scenes' audio
+// (sound\streams\nisaudio.big): no police radio, no voices in those scenes.
+#pragma once
+#include <cctype>
+#include <cstdint>
+#include <cstring>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace game::language
+{
+    constexpr uint32_t kBootCall = 0x823B48E0;       // after the boot's bl sub_822BCBC8 (SetCurrentLanguage)
+    constexpr uint32_t kMovieNameCall = 0x82282F00;  // after sub_82282E80's bl sub_82282A58 (the movie name)
+    constexpr uint32_t kNtscSuffix = 0x82078AA8;     // "_ntsc"
+    constexpr uint32_t kPalSuffix = 0x82078AB0;      // "_pal", unused by the USA build
+
+    struct Language
+    {
+        int32_t id;          // the game's index (its table at 0x828FF000)
+        const char* token;   // settings.toml / NFSMW_LANGUAGE
+        const char* name;    // the menu's
+        const char* disc;    // the table's name: LANGUAGES\<disc>.BIN, <movie>_<disc>_ntsc.wmv
+        const char* speech;  // the speech bank the game asks for: Sound\Speech\copspeech_<speech>.big
+    };
+
+    // In the game's indices' order (its table lists Polish and Finnish before
+    // Danish). Speech: the game's own choice (sub_821B82E8): French, German,
+    // Italian and Spanish have their own bank (copspeech_ge and _sp seen in
+    // its file opens; _fr and _it by the same pattern), the others English's.
+    inline constexpr Language kLanguages[] = {
+        { 0, "english", "English", "ENGLISH", "en" },
+        { 1, "french", "French", "FRENCH", "fr" },
+        { 2, "german", "German", "GERMAN", "ge" },
+        { 3, "italian", "Italian", "ITALIAN", "it" },
+        { 4, "spanish", "Spanish", "SPANISH", "sp" },
+        { 5, "dutch", "Dutch", "DUTCH", "en" },
+        { 6, "swedish", "Swedish", "SWEDISH", "en" },
+        { 7, "danish", "Danish", "DANISH", "en" },
+        { 12, "polish", "Polish", "POLISH", "en" },
+        { 13, "finnish", "Finnish", "FINNISH", "en" },
+    };
+    constexpr int32_t kEnglish = 0;
+
+    constexpr const Language* Find(int32_t id)
+    {
+        for (const Language& l : kLanguages)
+            if (l.id == id)
+                return &l;
+        return nullptr;
+    }
+
+    // The speech record: sub_821B82E8 switches on the language (or a debug
+    // override) and asks the attribute lookup sub_82148818 for collection
+    // kSpeechCollection, record r5: 1 French, 2 German, 3 Italian, 4 Spanish,
+    // 0 English (every other language). Its calls return inside the range.
+    constexpr uint32_t kSpeechPickBegin = 0x821B82E8;
+    constexpr uint32_t kSpeechPickEnd = 0x821B8628;
+    constexpr uint32_t kSpeechCollection = 0xC243117C;
+    constexpr uint32_t kEnglishSpeech = 0;
+
+    // The record the lookup gets: English's when `toEnglish` (the chosen
+    // language's bank is missing), only for sub_821B82E8's speech lookups.
+    constexpr uint32_t SpeechIndex(uint32_t lr, uint32_t r4, uint32_t r5, bool toEnglish)
+    {
+        return toEnglish && lr >= kSpeechPickBegin && lr < kSpeechPickEnd && r4 == kSpeechCollection ? kEnglishSpeech : r5;
+    }
+
+    // The language SetCurrentLanguage gets: the chosen one at the boot's call
+    // only. English (the default) never changes anything.
+    constexpr int32_t BootLanguage(uint32_t lr, int32_t r3, int32_t chosen)
+    {
+        return lr == kBootCall && chosen != kEnglish ? chosen : r3;
+    }
+
+    // The movie name's TV-system argument (r9 of the name's sprintf).
+    constexpr uint32_t MovieSuffix(uint32_t lr, uint32_t r9, bool palMovies)
+    {
+        return lr == kMovieNameCall && r9 == kNtscSuffix && palMovies ? kPalSuffix : r9;
+    }
+
+    // The archive index's key for a path (NFS/ZDIR.BIN: 24-byte entries, this
+    // hash first, little-endian, sorted): EA's string hash (h = h * 33 + c,
+    // from 0xFFFFFFFF) over the path without its drive, in upper case.
+    inline uint32_t ArchiveHash(std::string_view path)
+    {
+        if (size_t colon = path.find(':'); colon != std::string_view::npos)
+            path.remove_prefix(colon + 1);
+        while (!path.empty() && (path.front() == '\\' || path.front() == '/'))
+            path.remove_prefix(1);
+        uint32_t h = 0xFFFFFFFFu;
+        for (char c : path)
+            h = h * 33u + uint8_t(std::toupper(uint8_t(c == '/' ? '\\' : c)));
+        return h;
+    }
+
+    inline bool InArchive(const std::vector<uint8_t>& zdir, std::string_view path)
+    {
+        const uint32_t key = ArchiveHash(path);
+        for (size_t at = 0; at + 24 <= zdir.size(); at += 24)
+        {
+            uint32_t h = uint32_t(zdir[at]) | uint32_t(zdir[at + 1]) << 8 | uint32_t(zdir[at + 2]) << 16 | uint32_t(zdir[at + 3]) << 24;
+            if (h == key)
+                return true;
+        }
+        return false;
+    }
+
+    inline bool EndsWithNoCase(std::string_view s, std::string_view end)
+    {
+        if (s.size() < end.size())
+            return false;
+        for (size_t i = 0; i < end.size(); i++)
+            if (std::tolower(uint8_t(s[s.size() - end.size() + i])) != std::tolower(uint8_t(end[i])))
+                return false;
+        return true;
+    }
+
+    // Any of `movies` (file names in Movies/) is "<name>_<disc>_<tv>.wmv".
+    inline bool HasMovies(const std::vector<std::string>& movies, const Language& l, std::string_view tv)
+    {
+        const std::string end = std::string("_") + l.disc + "_" + std::string(tv) + ".wmv";
+        for (const std::string& m : movies)
+            if (m.size() > end.size() && EndsWithNoCase(m, end))
+                return true;
+        return false;
+    }
+
+    // What the installed files give one language.
+    struct Files
+    {
+        bool text = false;           // LANGUAGES\<disc>.BIN in the archive index
+        bool pal = false;            // the movie suffix: its PAL movies, and none of its NTSC ones
+        bool ownMovies = false;      // its own movies, with that suffix
+        bool englishMovies = false;  // the game's fallback, English movies with that suffix
+        bool speech = false;         // the bank the game asks for, in the archive index
+        bool englishSpeech = false;  // English's
+        bool speechToEnglish = false;  // the fallback: its own bank is missing, English's is there
+    };
+
+    inline Files Scan(const Language& l, const std::vector<std::string>& movies, const std::vector<uint8_t>& zdir)
+    {
+        Files f;
+        f.text = InArchive(zdir, std::string("LANGUAGES\\") + l.disc + ".BIN");
+        f.pal = HasMovies(movies, l, "pal") && !HasMovies(movies, l, "ntsc");
+        const char* tv = f.pal ? "pal" : "ntsc";
+        f.ownMovies = HasMovies(movies, l, tv);
+        f.englishMovies = HasMovies(movies, kLanguages[0], tv);
+        f.speech = InArchive(zdir, std::string("SOUND\\SPEECH\\COPSPEECH_") + l.speech + ".BIG");
+        f.englishSpeech = InArchive(zdir, "SOUND\\SPEECH\\COPSPEECH_EN.BIG");
+        f.speechToEnglish = std::string_view(l.speech) != "en" && !f.speech && f.englishSpeech;
+        return f;
+    }
+
+    // Which language the movies play in ("" for none).
+    inline std::string MoviesIn(const Language& l, const Files& f)
+    {
+        return f.ownMovies ? l.name : f.englishMovies ? kLanguages[0].name : "";
+    }
+
+    // Which language the speech (police radio, the in-game scenes' voices)
+    // is in ("" for none): the bank the game asks for, or English's in its
+    // place.
+    inline std::string SpeechIn(const Language& l, const Files& f)
+    {
+        if (f.speech)
+            return std::string_view(l.speech) == "en" ? kLanguages[0].name : l.name;
+        return f.speechToEnglish ? kLanguages[0].name : "";
+    }
+
+    // The menu's line under the row, for the language chosen there.
+    inline std::string Note(const Language& l, const Files& f)
+    {
+        const std::string name = l.name;
+        const std::string movies = MoviesIn(l, f), speech = SpeechIn(l, f);
+        if (f.text && movies == name && speech == name)
+            return "Menus, race text, movies and speech in " + name + ".";
+        std::string note = f.text ? "Menus and race text in " + name + "." : "The installed files have no " + name + " text.";
+        if (!movies.empty() && movies == speech)
+            return note + " Movies and speech in " + movies + ".";
+        note += movies.empty() ? " No movies (the installed files have none for it)." : " Movies in " + movies + ".";
+        note += speech.empty() ? " No speech (the installed files have none for it)." : " Speech in " + speech + ".";
+        return note;
+    }
+
+    // The menu's note for the language `id` with the installed files (read
+    // once; game/language.cpp). "" for an id not in the table.
+    std::string MenuNote(int32_t id);
+
+    // The log's line, once at boot.
+    inline std::string LogLine(const Language& l, const Files& f)
+    {
+        const std::string movies = MoviesIn(l, f), speech = SpeechIn(l, f);
+        return std::string("[language] ") + l.name + " (" + l.token + "): text " + (f.text ? "yes" : "none") + "; movies " +
+            (movies.empty() ? std::string("none") : movies) + " (_" + (f.pal ? "pal" : "ntsc") + "); speech " +
+            (speech.empty() ? std::string("none") : speech) + " (copspeech_" + l.speech +
+            (f.speech ? " present" : f.speechToEnglish ? " absent: English's instead" : " absent") + ")";
+    }
+}
diff --git a/runtime/gpu/command_processor.cpp b/runtime/gpu/command_processor.cpp
index aa7dcdd..c1a2d4e 100644
--- a/runtime/gpu/command_processor.cpp
+++ b/runtime/gpu/command_processor.cpp
@@ -664,7 +664,7 @@ namespace gpu
                             double(guard.snapReading - lastGuard.snapReading) / 120, double(guard.snapWaits - lastGuard.snapWaits) / 120,
                             double(guard.snapGaveUp - lastGuard.snapGaveUp) / 120);
                     fprintf(stderr, "[perf] %.1f fps (worst frame %.1f ms) | CP busy %.1f ms/frame (%.2f us/draw) | per frame: %.0f draws (%.0f skipped as later tiles, %.0f constant uploads), %.1f passes, %.1f resolves, %.1f submits, %.1f uploads, GPU busy %.1f ms (executing %.1f ms%s) | guard: %.1f faults (%.1f opened), %.2f stalls, %.2f ms stalled%s | %.0f KB snapshots | shadow: %.0f KB up, %.0f KB back, %.2f waits"
-                        " | scaled: %.1f loads, %.0f MB untiled, %.0f MB resolved, %.2f allocations, %.2f evictions, %.2f fallbacks | post-processing GPU %.2f ms (AA %.2f ms)"
+                        " | scaled: %.1f loads, %.0f MB untiled, %.0f MB resolved, %.2f allocations, %.2f evictions, %.2f fallbacks, %.1f stored into textures | post-processing GPU %.2f ms (AA %.2f ms)"
                         " | display: %llu dropped, %llu repeated | world: %llu frames, %llu without a step, %llu with 2+ | late %llu"
                         " | memory: %.0f MB (targets %.0f in %u, textures %.0f in %u, scaled %.0f, front %.0f), device %.0f of %.0f MB,"
                         " image blocks %u (%.0f MB: %.0f MB in %u images), %u spare (%.0f MB), %u images alone (%.0f MB)"
@@ -684,7 +684,7 @@ namespace gpu
                         double(scaled.untiledBytes - lastScaled.untiledBytes) / 1048576.0 / 120,
                         double(scaled.resolvedBytes - lastScaled.resolvedBytes) / 1048576.0 / 120,
                         double(scaled.allocations - lastScaled.allocations) / 120, double(scaled.evictions - lastScaled.evictions) / 120,
-                        double(scaled.fallbacks - lastScaled.fallbacks) / 120, double(post.totalNs - lastPost.totalNs) / 1e6 / postFrames,
+                        double(scaled.fallbacks - lastScaled.fallbacks) / 120, double(scaled.hosted - lastScaled.hosted) / 120, double(post.totalNs - lastPost.totalNs) / 1e6 / postFrames,
                         double(post.aaNs - lastPost.aaNs) / 1e6 / postFrames,
                         (unsigned long long)(shown.dropped - lastShown.dropped), (unsigned long long)(shown.repeated - lastShown.repeated),
                         (unsigned long long)(world.frames - lastWorld.frames), (unsigned long long)(world.noStep - lastWorld.noStep),
diff --git a/runtime/gpu/memory_plan.h b/runtime/gpu/memory_plan.h
index 416eaa4..7ab0a02 100644
--- a/runtime/gpu/memory_plan.h
+++ b/runtime/gpu/memory_plan.h
@@ -325,6 +325,25 @@ namespace gpu::memplan
         return p;
     }
 
+    // A discrete GPU that reads guest memory from system memory (imported, or
+    // a copy outside VRAM: no resizable BAR) fetches every vertex, constant
+    // and texture load, and stores every resolve, across PCIe. On the devices
+    // we measured, the ring alone in system memory doubled the GPU's time
+    // (NOTES: Steam Machine); issue #40's RTX 5060 Ti, on a PCIe 3.0 x8 link
+    // with both there, took 20-25 ms a frame at 1x. For the log: nullptr when
+    // the GPU reads its guest memory locally (VRAM, or an integrated GPU's
+    // own memory), else what to try.
+    inline const char* OverPcieNote(Gpu gpu, bool guestInVram, bool ringInVram)
+    {
+        if (gpu != Gpu::kDiscrete || guestInVram)
+            return nullptr;
+        return ringInVram
+            ? "the GPU reads guest memory over PCIe (it is in system memory); where Resizable BAR is off, turning it on "
+              "(\"Above 4G Decoding\" and \"Re-Size BAR\" in the firmware) puts it in VRAM"
+            : "the GPU reads guest memory and the upload ring over PCIe (both are in system memory); where Resizable BAR "
+              "is off, turning it on (\"Above 4G Decoding\" and \"Re-Size BAR\" in the firmware) puts them in VRAM";
+    }
+
     // The upload ring. `guestType`: the memory type guest memory's copy went
     // to (kNoType: imported), whose 512 MB count against the ring's heap.
     inline Plan PlanRing(const Memory& m, uint32_t bits, uint32_t guestType, Place override = Place::kImport)
diff --git a/runtime/gpu/pcie_link.h b/runtime/gpu/pcie_link.h
new file mode 100644
index 0000000..15ab3c2
--- /dev/null
+++ b/runtime/gpu/pcie_link.h
@@ -0,0 +1,123 @@
+// SpeedBreaker runtime. GPL-3.0-or-later (see COPYING).
+//
+// The PCIe link a discrete GPU sits on, for the logs and bug reports. On a
+// GPU without resizable BAR, guest memory and the upload ring stay in system
+// memory (gpu/memory_plan.h) and the GPU reads every vertex, constant and
+// texture load, and writes every resolve, across this link. Issue #40: an
+// RTX 5060 Ti (a PCIe x8 card) in a Ryzen 5600G system (PCIe 3.0 only),
+// 246 MB BAR window, took 20-25 ms of GPU time a frame at 1x where a Steam
+// Machine (resizable BAR: the copy in VRAM) takes 3-4; its report could not
+// say what the link was. Linux reads it from sysfs (VK_EXT_pci_bus_info gives
+// the address); elsewhere, or when sysfs has nothing, the link is unknown.
+// Vulkan-free and header only: tests/pcie_link_test.cpp checks it against a
+// sysfs-shaped folder.
+#pragma once
+#include <cstdint>
+#include <cstdio>
+#include <fstream>
+#include <string>
+
+namespace gpu::pcie
+{
+    struct Link
+    {
+        double gts = 0;        // current speed, GT/s (0: unknown); a GPU at rest drops it to save power
+        int width = 0;         // current lanes (0: unknown)
+        double maxGts = 0;     // the GPU's best
+        int maxWidth = 0;
+        double slotGts = 0;    // the port above it (the slot, or a bridge): its best
+        int slotWidth = 0;
+        bool Known() const { return maxGts > 0 && maxWidth > 0; }
+        // What the link can run at under load: the slower of the GPU and its slot.
+        double BestGts() const { return slotGts > 0 && slotGts < maxGts ? slotGts : maxGts; }
+        int BestWidth() const { return slotWidth > 0 && slotWidth < maxWidth ? slotWidth : maxWidth; }
+    };
+
+    // "8.0 GT/s PCIe" (or "8 GT/s", "2.5 GT/s"): 8.0. 0 when it isn't one.
+    inline double ParseSpeed(const std::string& s)
+    {
+        double v = 0;
+        if (std::sscanf(s.c_str(), "%lf", &v) != 1 || v <= 0 || v > 1000 || s.find("GT/s") == std::string::npos)
+            return 0;
+        return v;
+    }
+
+    // "8", "16" (lanes); 0 when it isn't one. ("x8" too, for safety.)
+    inline int ParseWidth(const std::string& s)
+    {
+        int v = 0;
+        const char* p = s.c_str();
+        while (*p == ' ' || *p == 'x' || *p == 'X')
+            p++;
+        if (std::sscanf(p, "%d", &v) != 1 || v <= 0 || v > 64)
+            return 0;
+        return v;
+    }
+
+    // The generation for a speed: 2.5 GT/s is PCIe 1.0 ... 64 GT/s is 6.0.
+    inline int Generation(double gts)
+    {
+        static const double kSpeeds[] = { 2.5, 5, 8, 16, 32, 64 };
+        for (int i = 0; i < 6; i++)
+            if (gts > kSpeeds[i] * 0.9 && gts < kSpeeds[i] * 1.1)
+                return i + 1;
+        return 0;
+    }
+
+    inline std::string Name(double gts, int width)
+    {
+        char s[48];
+        if (int gen = Generation(gts))
+            std::snprintf(s, sizeof(s), "PCIe %d.0 x%d", gen, width);
+        else
+            std::snprintf(s, sizeof(s), "PCIe %.1f GT/s x%d", gts, width);
+        return s;
+    }
+
+    // "PCIe 3.0 x8 at most (the GPU PCIe 5.0 x8, its slot PCIe 3.0 x16; now
+    // PCIe 1.0 x8)": the best the link can run at, what limits it, and what it
+    // reads now. Empty when unknown.
+    inline std::string Describe(const Link& l)
+    {
+        if (!l.Known())
+            return {};
+        std::string s = Name(l.BestGts(), l.BestWidth()) + " at most (the GPU " + Name(l.maxGts, l.maxWidth);
+        if (l.slotGts > 0 && l.slotWidth > 0)
+            s += ", its slot " + Name(l.slotGts, l.slotWidth);
+        if (l.gts > 0 && l.width > 0)
+            s += "; now " + Name(l.gts, l.width);
+        return s + ")";
+    }
+
+    // The sysfs folder of a PCI device: /sys/bus/pci/devices/0000:01:00.0.
+    inline std::string SysfsDir(uint32_t domain, uint32_t bus, uint32_t device, uint32_t function, const char* root = "/sys/bus/pci/devices")
+    {
+        char s[64];
+        std::snprintf(s, sizeof(s), "/%04x:%02x:%02x.%x", domain & 0xFFFF, bus & 0xFF, device & 0x1F, function & 0x7);
+        return root + std::string(s);
+    }
+
+    inline std::string ReadLine(const std::string& path)
+    {
+        std::ifstream f(path);
+        std::string s;
+        if (f)
+            std::getline(f, s);
+        return s;
+    }
+
+    // The link from a device's sysfs folder (zeros where it can't be read).
+    // `dir`/.. is the port above it: the kernel resolves ".." after following
+    // /sys/bus/pci/devices' link into /sys/devices.
+    inline Link Read(const std::string& dir)
+    {
+        Link l;
+        l.gts = ParseSpeed(ReadLine(dir + "/current_link_speed"));
+        l.width = ParseWidth(ReadLine(dir + "/current_link_width"));
+        l.maxGts = ParseSpeed(ReadLine(dir + "/max_link_speed"));
+        l.maxWidth = ParseWidth(ReadLine(dir + "/max_link_width"));
+        l.slotGts = ParseSpeed(ReadLine(dir + "/../max_link_speed"));
+        l.slotWidth = ParseWidth(ReadLine(dir + "/../max_link_width"));
+        return l;
+    }
+}
diff --git a/runtime/gpu/render_scale.h b/runtime/gpu/render_scale.h
index 0b1ca4c..2f7c97f 100644
--- a/runtime/gpu/render_scale.h
+++ b/runtime/gpu/render_scale.h
@@ -50,6 +50,28 @@
 // else it is used at 1x; a resolve needs an even origin, which the 8-pixel
 // alignment gives (else it isn't kept at host resolution, logged once).
 //
+// Native rows and columns (GitHub #34): on a screen of another shape the
+// axis a Vert+ or Hor+ picture extends gets the host pixels the screen has
+// there, so a Steam Deck's 1280x800 renders 1280x800 at 1x, not 720 rows
+// stretched: 800 rows for 720 is 10/9, and a den above 2 (9; 3 for 5/3 at
+// 1.5x; 720 for a MacBook's 803 rows) is a texel axis. Its edges are where
+// the rasteriser puts them for any ratio: guest edge g is host edge
+// ceil(g num / den - 1/2), the first host pixel whose centre lies at or past
+// it (sbHostEdge; the same floor(g num / den) for a den of 1 or 2), and guest
+// pixel g owns the host pixels whose centres lie inside it, one or two at
+// 10/9. A texel axis has no blocks: each texel keeps ceil(num / den) samples
+// along it (sbStride; 2 at 10/9, 8 KB a 4 KB page), the ones it owns first,
+// the rest repeating its last (a reader that disagrees about where a texel's
+// samples end still reads that texel, never another's or garbage). Which
+// texel owns which host pixels depends on the texel's coordinate, not on
+// bits of its word, so a resolve counts it in the source target (the
+// screen's coordinates in untiled rendering: tile strips at rows 256 and 512
+// are 284 and 569 host rows down at 10/9), and so does a texture or the
+// front buffer reading the surface from its own first texel: the scene's
+// strips, its side-by-side halves and the right-half texture read back
+// sample for sample (render_scale_test). Any surface size or resolve origin
+// works (Exact is always true there).
+//
 // The block arithmetic is written once, in tokens that are both GLSL and
 // C++ (SB_SCALE_FUNCTIONS, as gpu/depth24_glsl.h does for its pack): the shaders
 // get it as text (GLSL_SCALE_CODE, spliced into renderer.cpp's resolve,
@@ -65,14 +87,24 @@
 // uint arithmetic only (wrapping 32-bit in both languages); `1u` literals,
 // min/max of two uints, if, ?:. Every function's name starts "sb".
 #define SB_SCALE_FUNCTIONS                                                                                       \
-    /* Host edge of guest edge g: floor(g num / den). */                                                         \
-    uint sbHostEdge(uint g, uint num, uint den) { return g * num / den; }                                        \
-    /* The host pixels covering guest pixels [0, g): ceil(g num / den), a target's or image's size. */           \
+    /* Host edge of guest edge g: floor(g num / den); for a den above 2 (a texel axis) the rasteriser's, */       \
+    /* ceil(g num / den - 1/2), the same for a den of 1 or 2. */                                                 \
+    uint sbHostEdge(uint g, uint num, uint den)                                                                  \
+    {                                                                                                            \
+        return den > 2u ? (2u * g * num + den - 1u) / (2u * den) : g * num / den;                                \
+    }                                                                                                            \
+    /* The host pixels touching guest pixels [0, g): ceil(g num / den) (a box filter's reach). */                \
     uint sbHostSize(uint g, uint num, uint den) { return (g * num + den - 1u) / den; }                            \
-    /* The guest edge whose host edge is h (h from sbHostEdge): ceil(h den / num). */                             \
-    uint sbGuestEdge(uint h, uint num, uint den) { return (h * den + num - 1u) / num; }                           \
+    /* The guest edge whose host edge is h (h from sbHostEdge). */                                               \
+    uint sbGuestEdge(uint h, uint num, uint den)                                                                 \
+    {                                                                                                            \
+        return den > 2u ? (2u * h * den + 2u * num - den) / (2u * num) : (h * den + num - 1u) / num;             \
+    }                                                                                                            \
     /* The guest pixel owning host pixel h: the g with HostEdge(g) <= h < HostEdge(g + 1). */                     \
-    uint sbOwner(uint h, uint num, uint den) { return ((h + 1u) * den + num - 1u) / num - 1u; }                   \
+    uint sbOwner(uint h, uint num, uint den)                                                                     \
+    {                                                                                                            \
+        return den > 2u ? ((2u * h + 1u) * den) / (2u * num) : ((h + 1u) * den + num - 1u) / num - 1u;            \
+    }                                                                                                            \
     /* How much of host pixel h lies in guest pixel g, in 1/den of a pixel (num for the whole guest pixel). */   \
     uint sbOverlap(uint g, uint h, uint num, uint den)                                                           \
     {                                                                                                            \
@@ -82,6 +114,10 @@
     }                                                                                                            \
     /* The one host pixel a depth resolve reads for guest pixel g. */                                            \
     uint sbCenterHost(uint g, uint num, uint den) { return den == 1u ? g * num : ((2u * g + 1u) * num) / (2u * den); } \
+    /* A block's samples along an axis: num, or on a texel axis ceil(num / den), a texel's most. */              \
+    uint sbStride(uint num, uint den) { return den > 2u ? (num + den - 1u) / den : num; }                         \
+    /* A block's texels along an axis: den, or 1 on a texel axis. */                                             \
+    uint sbLayoutDen(uint den) { return den > 2u ? 1u : den; }                                                   \
     /* A word of a 4 KB page of 32-bit tiled texels (0..1023): its block (the sub-texel bits out). */             \
     uint sbBlockIndex(uint w, uint denX, uint denY)                                                              \
     {                                                                                                            \
@@ -104,11 +140,43 @@
     uint sbSubX(uint w, uint denX) { return denX == 2u ? (w & 1u) : 0u; }                                        \
     uint sbSubY(uint w, uint denY) { return denY == 2u ? ((w >> 2u) & 1u) : 0u; }                                \
     /* A 4 KB page's samples: its blocks' x theirs. */                                                           \
-    uint sbSlotWords(uint numX, uint numY, uint denX, uint denY) { return 1024u / (denX * denY) * (numX * numY); } \
-    /* Host sample (i, j) of word w's block, i < numX and j < numY from the block's corner: its word in the slot. */ \
+    uint sbSlotWords(uint numX, uint numY, uint denX, uint denY)                                                 \
+    {                                                                                                            \
+        return 1024u / (sbLayoutDen(denX) * sbLayoutDen(denY)) * (sbStride(numX, denX) * sbStride(numY, denY));  \
+    }                                                                                                            \
+    /* Host sample (i, j) of word w's block, i and j from the block's corner (below its strides): its word in the slot. */ \
     uint sbSampleWord(uint w, uint i, uint j, uint numX, uint numY, uint denX, uint denY)                        \
     {                                                                                                            \
-        return sbBlockIndex(w, denX, denY) * (numX * numY) + j * numX + i;                                       \
+        return sbBlockIndex(w, denX, denY) * (sbStride(numX, denX) * sbStride(numY, denY)) + j * sbStride(numX, denX) + i; \
+    }                                                                                                            \
+    /* A reader's host pixel h: the first texel of the block holding it (h / num x den: the block's corner), */  \
+    /* or on a texel axis its owner. */                                                                          \
+    uint sbBlockTexel(uint h, uint num, uint den) { return den > 2u ? sbOwner(h, num, den) : h / num * den; }     \
+    /* ... and its sample there, from the block's corner. */                                                     \
+    uint sbBlockSample(uint h, uint num, uint den)                                                               \
+    {                                                                                                            \
+        return den > 2u ? h - sbHostEdge(sbOwner(h, num, den), num, den) : h - h / num * num;                    \
+    }                                                                                                            \
+    /* A writer's samples [lo, hi) of the texel at sub in its block: the host pixels it owns, from the */        \
+    /* block's corner; on a texel axis all its stride (past the ones it owns, its last again). */                \
+    uint sbSampleLo(uint sub, uint num, uint den) { return den > 2u ? 0u : sbHostEdge(sub, num, den); }          \
+    uint sbSampleHi(uint sub, uint num, uint den) { return den > 2u ? sbStride(num, den) : sbHostEdge(sub + 1u, num, den); } \
+    /* Where sample i (from sbSampleLo) of guest pixel g (sub in its block) is in a target counted from guest */ \
+    /* pixel 0: on a texel axis its i-th host pixel, or its last one past them. */                               \
+    uint sbSampleHost(uint g, uint sub, uint i, uint num, uint den)                                              \
+    {                                                                                                            \
+        if (den > 2u)                                                                                            \
+            return sbHostEdge(g, num, den) + min(i, sbHostEdge(g + 1u, num, den) - sbHostEdge(g, num, den) - 1u); \
+        return sbHostEdge(g - sub, num, den) + i;                                                                \
+    }                                                                                                            \
+    /* A writer's sample i (from sbSampleLo) of a reader's texel t (sub in its block, t counted from the */      \
+    /* reader's own first texel): the reader's host pixel the untile fills with it, or ~0u for a texel */        \
+    /* axis's repeated padding past the host pixels t owns (a resolve storing straight into a texture). */       \
+    uint sbReaderHost(uint t, uint sub, uint i, uint num, uint den)                                              \
+    {                                                                                                            \
+        if (den > 2u)                                                                                            \
+            return i < sbHostEdge(t + 1u, num, den) - sbHostEdge(t, num, den) ? sbHostEdge(t, num, den) + i : ~0u; \
+        return sbHostEdge(t - sub, num, den) + i;                                                                \
     }
 
 #define SB_SCALE_STRINGIFY_(...) #__VA_ARGS__
@@ -129,19 +197,27 @@ namespace gpu
         SB_SCALE_FUNCTIONS
     };
 
-    // One axis: num host pixels for every den guest pixels (den 1 or 2).
+    // One axis: num host pixels for every den guest pixels, reduced (den 1
+    // or 2: blocks; above 2: a texel axis, num / den above 1).
     struct AxisScale
     {
         uint32_t num = 1, den = 1;
 
         bool operator==(const AxisScale&) const = default;
         bool IsOne() const { return num == den; }
+        // No blocks: each texel's samples apart (a den above 2).
+        bool Texel() const { return den > 2; }
         float Value() const { return float(num) / float(den); }
         uint32_t Edge(uint32_t g) const { return ScaleGlsl{}.sbHostEdge(g, num, den); }
-        uint32_t Size(uint32_t g) const { return ScaleGlsl{}.sbHostSize(g, num, den); }
+        // The host pixels of g guest ones (a target's or image's size): on a
+        // texel axis those the g own, so every host pixel has an owner.
+        uint32_t Size(uint32_t g) const { return Texel() ? Edge(g) : ScaleGlsl{}.sbHostSize(g, num, den); }
         uint32_t GuestEdge(uint32_t h) const { return ScaleGlsl{}.sbGuestEdge(h, num, den); }
-        // Guest length g covers whole host pixels (every block whole).
-        bool Exact(uint32_t g) const { return g % den == 0; }
+        // A block's samples along the axis (a texel's most on a texel axis).
+        uint32_t Stride() const { return ScaleGlsl{}.sbStride(num, den); }
+        // Guest length g covers whole host pixels (every block whole; any
+        // length on a texel axis).
+        bool Exact(uint32_t g) const { return Texel() || g % den == 0; }
         // A guest coordinate clamped to 0 first (rectangles' signed edges).
         int32_t EdgeAt(int32_t g) const { return g <= 0 ? 0 : int32_t(Edge(uint32_t(g))); }
     };
@@ -152,8 +228,9 @@ namespace gpu
 
         bool operator==(const RenderScale&) const = default;
         bool IsOne() const { return x.IsOne() && y.IsOne(); }
-        // Host samples a block of den.x x den.y guest texels has.
-        uint32_t SamplesPerBlock() const { return x.num * y.num; }
+        // Host samples a block of den.x x den.y guest texels has (one texel
+        // on a texel axis, its most).
+        uint32_t SamplesPerBlock() const { return x.Stride() * y.Stride(); }
         // A 4 KB guest page's host samples (words) in the scaled memory.
         uint32_t SlotWords() const { return ScaleGlsl{}.sbSlotWords(x.num, y.num, x.den, y.den); }
         // A width x height surface maps to whole host pixels and blocks.
@@ -168,6 +245,20 @@ namespace gpu
         static RenderScale Whole(uint32_t sx, uint32_t sy) { return { { sx, 1 }, { sy, 1 } }; }
     };
 
+    // The scaled resolve memory's default size in MB (renderer.cpp's
+    // EnsureScaledMemory): 512 on a discrete GPU; on an integrated one, whose
+    // VRAM is the system's (a Steam Deck's 1 GB carve-out), room for 16,384
+    // guest pages at `s` (64 MB of guest memory; a career start and its
+    // first race resolve ~4,200 pages at every scale), at most 512: 128 MB at
+    // a Steam Deck's native rows (1x10/9), 256 at 2x.
+    inline uint64_t ScaledPoolMegabytes(const RenderScale& s, bool discrete)
+    {
+        constexpr uint64_t kIntegratedSlots = 16384;
+        if (discrete)
+            return 512;
+        return std::min<uint64_t>(512, (kIntegratedSlots * 4ull * s.SlotWords() + (1u << 20) - 1) >> 20);
+    }
+
     // An axis from a number of half steps (2: 1x, 3: 1.5x, 4: 2x, 6: 3x),
     // reduced (4/2 is 2/1).
     inline AxisScale AxisFromHalves(uint32_t halves)
@@ -176,17 +267,39 @@ namespace gpu
         return halves % 2 == 0 ? AxisScale{ halves / 2, 1 } : AxisScale{ halves, 2 };
     }
 
-    // "1", "1.5", "2" (the log's and settings' spelling).
+    // num / den with no common factor.
+    inline AxisScale Reduced(uint32_t num, uint32_t den)
+    {
+        uint32_t a = num, b = den;
+        while (b)
+        {
+            const uint32_t t = a % b;
+            a = b;
+            b = t;
+        }
+        return a > 1 ? AxisScale{ num / a, den / a } : AxisScale{ num, den };
+    }
+
+    // The axis that gives `guest` pixels `host` host pixels exactly (720
+    // rows for 800: 10/9), reduced; 1x for a host below the guest.
+    inline AxisScale AxisFor(uint32_t host, uint32_t guest)
+    {
+        if (guest == 0 || host <= guest)
+            return {};
+        return Reduced(host, guest);
+    }
+
+    // "1", "1.5", "2", "1.111" (10/9) (the log's and settings' spelling).
     inline std::string AxisName(const AxisScale& a)
     {
         if (a.den == 1)
             return std::to_string(a.num);
         char text[16];
-        snprintf(text, sizeof(text), "%g", double(a.num) / double(a.den));
+        snprintf(text, sizeof(text), a.Texel() ? "%.4g" : "%g", double(a.num) / double(a.den));
         return text;
     }
 
-    // "1x1", "1.5x1.5", "3x2": as the log has always named the scale.
+    // "1x1", "1.5x1.5", "3x2", "1x1.111": as the log has always named the scale.
     inline std::string ScaleName(const RenderScale& s)
     {
         return AxisName(s.x) + "x" + AxisName(s.y);
@@ -210,30 +323,54 @@ namespace gpu
         return true;
     }
 
+    // One axis of NFSMW_RENDER_SCALE from `text`, `end` past it: a number
+    // (AxisFromNumber's), or a ratio <num>/<den> from 1 to 4 ("10/9": a
+    // Steam Deck's native rows at 1x), reduced.
+    inline bool ParseAxis(const char* text, const char*& end, AxisScale& out)
+    {
+        char* stop = nullptr;
+        const double v = std::strtod(text, &stop);
+        if (stop == text)
+            return false;
+        if (*stop != '/')
+        {
+            end = stop;
+            return AxisFromNumber(v, out);
+        }
+        const char* second = stop + 1;
+        const unsigned long den = std::strtoul(second, &stop, 10);
+        const double num = v;
+        if (stop == second || den == 0 || den > 4096 || num != std::floor(num) || num < double(den) || num > 4.0 * double(den))
+            return false;
+        const AxisScale r = Reduced(uint32_t(num), uint32_t(den));
+        if (r.den == 2 && r.num != 3)
+            return false;  // 2.5x, 3.5x: not offered (as AxisFromNumber)
+        end = stop;
+        out = r;
+        return true;
+    }
+
     // NFSMW_RENDER_SCALE: "<s>" or "<sx>x<sy>", each 1, 1.5, 2, 3 or 4
-    // ("2", "1.5", "3x2", "1.5x1"); whole numbers above 4 are clamped to 4,
-    // as before. False for anything else (the caller logs it).
+    // ("2", "1.5", "3x2", "1.5x1") or a ratio ("1x10/9"); whole numbers above
+    // 4 are clamped to 4, as before. False for anything else (the caller
+    // logs it).
     inline bool ParseRenderScale(const char* text, RenderScale& out)
     {
         if (!text || !*text)
             return false;
-        char* end = nullptr;
-        const double a = std::strtod(text, &end);
-        if (end == text)
+        const char* end = nullptr;
+        RenderScale s;
+        if (!ParseAxis(text, end, s.x))
             return false;
-        double b = a;
+        s.y = s.x;
         if (*end == 'x' || *end == 'X')
         {
             const char* second = end + 1;
-            b = std::strtod(second, &end);
-            if (end == second)
+            if (!ParseAxis(second, end, s.y))
                 return false;
         }
         if (*end != '\0')
             return false;
-        RenderScale s;
-        if (!AxisFromNumber(a, s.x) || !AxisFromNumber(b, s.y))
-            return false;
         out = s;
         return true;
     }
diff --git a/runtime/gpu/renderer.cpp b/runtime/gpu/renderer.cpp
index 5c65037..5588612 100644
--- a/runtime/gpu/renderer.cpp
+++ b/runtime/gpu/renderer.cpp
@@ -1902,8 +1902,12 @@ namespace gpu::renderer
         // guest pixel's host pixels down into guest memory (depth takes one
         // sample), so the game and the texture cache see 1x data as before.
         // The scale is a ratio on each axis (gpu/render_scale.h): 1, 1.5
-        // (3 host pixels for every 2 guest ones: 1920x1080), 2, 3, 4.
-        // NFSMW_RENDER_SCALE=<n> or <sx>x<sy> (1, 1.5, 2, 3 or 4; default 1).
+        // (3 host pixels for every 2 guest ones: 1920x1080), 2, 3, 4, and on
+        // the axis a Vert+ or Hor+ picture extends, the screen's own rows or
+        // columns at that density (video::NativeShape: 1x10/9 on a Steam
+        // Deck's 1280x800, GitHub #34).
+        // NFSMW_RENDER_SCALE=<n> or <sx>x<sy> (1, 1.5, 2, 3 or 4, or a ratio
+        // such as 10/9; default 1): exactly that, no native rows or columns.
         // The setting applies live (ApplyLiveSettings): every scaled target,
         // the scaled resolve memory and the scaled textures are made again at
         // the new scale between two frames, and Auto follows the picture's
@@ -1912,18 +1916,30 @@ namespace gpu::renderer
         uint32_t s_scalePitchMin = 640, s_scalePitchMax = 1280;
         uint32_t s_scaleBudget = 6;  // Auto's most host pixels per guest pixel
         bool s_scaleFixed = false;   // NFSMW_RENDER_SCALE: no live changes
+        // Native rows and columns on a Vert+ or Hor+ picture (video::NativeShape);
+        // NFSMW_NATIVE_SHAPE=0 keeps the setting's scale on both axes, as
+        // before (an A/B switch).
+        const bool s_nativeShape = [] {
+            const char* v = std::getenv("NFSMW_NATIVE_SHAPE");
+            return !(v && v[0] == '0');
+        }();
 
         // What the Internal Resolution setting asks for with the picture
         // covering `regionW` x `regionH` of the swapchain.
         // The setting's value is the scale in half steps (settings.h: 2 is
-        // 1x, 3 is 1.5x, 4 is 2x, 6 is 3x). Auto (whole scales only, for
-        // now: video::AutoRenderScale) could pick 1.5x by returning one.
+        // 1x, 3 is 1.5x, 4 is 2x, 6 is 3x): that many host pixels for each
+        // guest one across a Vert+ picture (down a Hor+ one), and on the axis
+        // it extends the picture's own shape at that density, 1:1 on the
+        // screen at 1x on a Steam Deck (video::NativeShape). A 16:9 picture
+        // gets the setting's scale both ways, as before. Auto (whole scales
+        // only, for now: video::AutoRenderScale) could pick 1.5x by returning
+        // one.
         gpu::RenderScale WantedRenderScale(int32_t setting, uint32_t regionW, uint32_t regionH)
         {
             if (setting > 0)
             {
                 gpu::AxisScale a = gpu::AxisFromHalves(uint32_t(std::clamp(setting, 2, 6)));
-                return { a, a };
+                return s_nativeShape ? video::NativeShape(a, regionW, regionH) : gpu::RenderScale{ a, a };
             }
             uint32_t sx = 1, sy = 1;
             // Auto: enough host pixels to cover the screen area the frame
@@ -1947,16 +1963,37 @@ namespace gpu::renderer
                 return gpu::RenderScale::Whole(sx, sy);
             }
             video::AutoRenderScale(regionW, regionH, s_scaleBudget, sx, sy);
-            return gpu::RenderScale::Whole(sx, sy);
+            // A Vert+ or Hor+ picture's own rows or columns at that scale,
+            // within the budget too (video::NativeAuto: the Deck's 1x10/9).
+            return s_nativeShape ? video::NativeAuto(sx, sy, regionW, regionH, s_scaleBudget) : gpu::RenderScale::Whole(sx, sy);
         }
 
         std::string ScaleReason(int32_t setting, uint32_t regionW, uint32_t regionH)
         {
             if (s_scaleFixed)
                 return "NFSMW_RENDER_SCALE";
+            // Native rows or columns: unlike the setting's (Auto's) scale on its own.
+            gpu::RenderScale plain;
             if (setting > 0)
-                return "setting";
-            return std::format("auto for a {}x{} picture{}", regionW, regionH, hfr::Enabled() && video::HfrOffered() ? ", half the budget for Smooth Motion's two pictures a step" : "");
+            {
+                const gpu::AxisScale a = gpu::AxisFromHalves(uint32_t(std::clamp(setting, 2, 6)));
+                plain = { a, a };
+            }
+            else
+            {
+                uint32_t sx = 1, sy = 1;
+                const bool hfrAuto = hfr::Enabled() && video::HfrOffered();
+                video::AutoRenderScale(regionW, regionH, hfrAuto ? std::max(1u, s_scaleBudget / 2) : s_scaleBudget, sx, sy);
+                if (hfrAuto)
+                    sx = sy = std::min(sx, sy);
+                plain = gpu::RenderScale::Whole(sx, sy);
+            }
+            const gpu::RenderScale want = WantedRenderScale(setting, regionW, regionH);
+            const char* native = want == plain ? "" : !(want.y == plain.y) ? ", the picture's own rows" : ", the picture's own columns";
+            if (setting > 0)
+                return std::format("setting{}{}", native, *native ? std::format(" for a {}x{} picture", regionW, regionH) : "");
+            return std::format("auto for a {}x{} picture{}{}", regionW, regionH, native,
+                               hfr::Enabled() && video::HfrOffered() ? ", half the budget for Smooth Motion's two pictures a step" : "");
         }
 
         void ReadRenderScale(const VkPhysicalDeviceProperties& props)
@@ -2006,7 +2043,8 @@ namespace gpu::renderer
             else
             {
                 if (fixed)
-                    fprintf(stderr, "[renderer] NFSMW_RENDER_SCALE=%s ignored: each axis takes 1, 1.5, 2, 3 or 4 (\"1.5\", \"3x2\")\n", fixed);
+                    fprintf(stderr, "[renderer] NFSMW_RENDER_SCALE=%s ignored: each axis takes 1, 1.5, 2, 3 or 4 or a ratio (\"1.5\", \"3x2\", "
+                        "\"1x10/9\")\n", fixed);
                 video::FrameRegion(regionW, regionH);
                 s_renderScale = WantedRenderScale(setting, regionW, regionH);
             }
@@ -3377,16 +3415,23 @@ namespace gpu::renderer
             VkDeviceSize poolBytes = 0, tableBytes = 0, scratchBytes = 0;  // allocated (the [perf] line's memory)
             std::vector<uint32_t> pageSlot;  // slot + 1; 0: none
             std::vector<uint64_t> pageSeq;   // write sequence after the page's last scaled resolve; 0: none or stale
+            // The cached scaled texture (a Texture) that alone holds the page's
+            // samples: its last scaled resolve stored them there and not in
+            // the pool (see Resolve). Null: the pool has them (if current).
+            std::vector<const void*> pageHeld;
             std::vector<uint32_t> slotPage;  // page + 1; 0: free
             std::vector<uint8_t> slotRef;    // clock bit (used since the hand last passed)
             uint32_t clock = 0;
             std::vector<uint32_t> dirty;     // pages whose table entry changed
             uint64_t allocations = 0, evictions = 0, textures = 0, fallbacks = 0;
             uint64_t loads = 0, untiledBytes = 0, resolvedBytes = 0;  // for the [perf] line
+            uint64_t hosted = 0;  // scaled resolves that stored into their scaled texture too
             uint32_t hostPageGuestPages = 1;  // guest pages per host page (write sequences are per host page)
         } s_scaled;
 
         bool EnsureScaledMemory();
+        bool ScaledWanted(uint32_t base, uint32_t size);
+        bool ScaledWanted(uint32_t base, uint32_t size, uint32_t exceptBase, uint32_t exceptSize, uint64_t exceptSig);
         void FillFreshSlots(const std::vector<std::pair<uint32_t, uint32_t>>& fresh);
 
         // The page's slot, allocated (clock replacement) if it has none.
@@ -3417,6 +3462,7 @@ namespace gpu::renderer
                 uint32_t old = s_scaled.slotPage[slot] - 1;
                 s_scaled.pageSlot[old] = 0;
                 s_scaled.pageSeq[old] = 0;
+                s_scaled.pageHeld[old] = nullptr;
                 s_scaled.dirty.push_back(old);
                 s_scaled.evictions++;
                 break;
@@ -3454,11 +3500,17 @@ namespace gpu::renderer
             FullBarrier();
         }
 
-        // The page's scaled copy is current (see above).
+        // The page's scaled copy is current (see above) and in the pool.
         bool ScaledPageValid(uint32_t page)
         {
             uint64_t seq = s_scaled.pageSeq[page];
-            return seq != 0 && s_scaled.pageSlot[page] != 0 && writewatch::WriteSequence(page << 12, 4096) == seq;
+            return seq != 0 && s_scaled.pageSlot[page] != 0 && !s_scaled.pageHeld[page] && writewatch::WriteSequence(page << 12, 4096) == seq;
+        }
+        // ... current, but only in the scaled texture holding it (pageHeld).
+        bool ScaledPageHeld(uint32_t page)
+        {
+            uint64_t seq = s_scaled.pageSeq[page];
+            return seq != 0 && s_scaled.pageSlot[page] != 0 && s_scaled.pageHeld[page] && writewatch::WriteSequence(page << 12, 4096) == seq;
         }
 
         // Every page of [base, base + size) has a current scaled copy.
@@ -3656,6 +3708,8 @@ void main()
             uint32_t levels = 1;
             uint32_t mipStart = 0, mipSize = 0;  // the mip levels' guest memory (size 0: none)
             bool scaled = false;  // host resolution, from the scaled resolve memory
+            uint32_t guestWidth = 0, guestHeight = 0;  // scaled: its guest size (width, height are the host's)
+            uint64_t scaledSig = 0;  // scaled: ScaledSignature
             VkImageView storeView = VK_NULL_HANDLE;  // scaled: R32_UINT, stored into by the untile (if the device can)
             // The same, a 2D view of each layer: [0] is storeView, and a
             // direct cube (NFSMW_DIRECT_CUBE) has one per face.
@@ -3673,7 +3727,62 @@ void main()
             uint64_t verifyFrame = 0;
         };
         void LoadScaledTexture(Texture& t, uint32_t base, uint32_t pitchBlocks, uint32_t endian);
-        bool ScaledTextureValid(uint32_t base, uint32_t size);
+        bool ScaledTextureValid(uint32_t base, uint32_t size, uint64_t sig);
+        // A scaled texture's surface: its guest format, size, pitch and
+        // endianness (with its first byte and guest size, its cache key's
+        // fields for a scaled texture).
+        uint64_t ScaledSignature(uint32_t format, uint32_t width, uint32_t height, uint32_t pitch, uint32_t endian)
+        {
+            uint64_t h = 0x9E3779B97F4A7C15ull;
+            for (uint64_t v : { uint64_t(format), uint64_t(width), uint64_t(height), uint64_t(pitch), uint64_t(endian) })
+                h = (h ^ v) * 0x100000001B3ull;
+            return h | 1;  // (never 0: no texture)
+        }
+
+        // Every page of the surface [base, base + size) has current samples
+        // for the scaled texture `sig` there: in the pool, or held by that
+        // very texture (pageHeld) while it is current (nothing written there
+        // since its load or its last resolve). A held page is never current
+        // for any other reader (the pool's copy of it is old).
+        bool ScaledSurfaceValid(uint32_t base, uint32_t size, uint64_t sig)
+        {
+            if (!s_scaled.enabled || size == 0)
+                return false;
+            uint32_t first = base >> 12, last = std::min<uint32_t>((base + size - 1) >> 12, kGuestPages - 1);
+            const void* checked = nullptr;
+            for (uint32_t page = first; page <= last; page++)
+            {
+                if (ScaledPageValid(page))
+                    continue;
+                if (!ScaledPageHeld(page))
+                    return false;
+                const void* holder = s_scaled.pageHeld[page];
+                if (holder != checked)
+                {
+                    const Texture& t = *static_cast<const Texture*>(holder);
+                    if (!sig || !t.scaled || t.scaledSig != sig || t.guestStart != base || t.guestSize != size || !t.uploaded ||
+                        writewatch::WrittenSince(t.guestStart, t.guestSize, t.loadedSequence))
+                        return false;
+                    checked = holder;
+                }
+            }
+            for (uint32_t page = first; page <= last; page++)
+                s_scaled.slotRef[s_scaled.pageSlot[page] - 1] = 1;
+            return true;
+        }
+        // A page held by `t` no longer is: its samples are gone (`t` dropped).
+        void ReleaseHeldPages(const void* t, uint32_t base, uint32_t size)
+        {
+            if (!s_scaled.enabled || size == 0 || s_scaled.pageHeld.empty())
+                return;
+            uint32_t first = base >> 12, last = std::min<uint32_t>((base + size - 1) >> 12, kGuestPages - 1);
+            for (uint32_t page = first; page <= last; page++)
+                if (s_scaled.pageHeld[page] == t)
+                {
+                    s_scaled.pageHeld[page] = nullptr;
+                    s_scaled.pageSeq[page] = 0;
+                }
+        }
         std::unordered_map<uint64_t, std::unique_ptr<Texture>> s_textures;
         // Direct 1x 2D textures by guest address (the latest made there), for
         // resolves that store into them too (DestroyTexture drops its entry).
@@ -3681,6 +3790,12 @@ void main()
         // Resolves store into such a texture too when it is exactly their
         // surface (see Resolve); NFSMW_RESOLVE_TO_TEXTURE=0 turns it off.
         const bool s_resolveToTexture = [] { const char* v = std::getenv("NFSMW_RESOLVE_TO_TEXTURE"); return !v || v[0] != '0'; }();
+        // ... also from a scaled resolve (its 1x words); NFSMW_SCALED_FUSE=0
+        // turns that off (and the scaled textures' own, see Resolve).
+        const bool s_scaledFuse = [] { const char* v = std::getenv("NFSMW_SCALED_FUSE"); return !v || v[0] != '0'; }();
+        // ... and then only there, where no other reader asks (see Resolve);
+        // NFSMW_SCALED_HOLD=0: into the pool as well, always.
+        const bool s_scaledHold = [] { const char* v = std::getenv("NFSMW_SCALED_HOLD"); return !v || v[0] != '0'; }();
         // NFSMW_FUSE_PARTIAL=1 (default kFewerPasses; 0: only a resolve
         // covering the whole texture stores into it): a resolve into whole 32x32 tiles
         // inside a direct texture (or a cube's face) stores there too, at
@@ -3695,6 +3810,11 @@ void main()
         // largest one's guest size, how far before an address one holding
         // it can start.
         std::map<uint32_t, Texture*> s_directByStart;
+        // Scaled textures stored into directly, by their first guest byte (the
+        // latest made there), for scaled resolves into them (Resolve); the
+        // largest one's guest size.
+        std::map<uint32_t, Texture*> s_scaledByStart;
+        uint32_t s_maxScaledSize = 0;
         uint32_t s_maxDirectSize = 0;
 
         // NFSMW_LOG_UPLOADS=<first>[,<last>]: in those frames (s_frame, as
@@ -3998,6 +4118,7 @@ void main()
             Texture* texture = nullptr;
             uint32_t base = 0, size = 0, mipBase = 0, mipSize = 0;
             bool scaledCandidate = false;  // a draw into scaled targets may take the scaled path
+            uint64_t sig = 0;              // ScaledSignature
         };
 
         // The full lookup (GetTexture below keeps its results).
@@ -4116,10 +4237,13 @@ void main()
             bool scaledCandidate = !cube && !volume && f.tiled && layers == 1 && !f.stacked &&
                 ScaledFormat(fi) && offX == 0 && offY == 0 && maxLevel == 0 && s_scaled.scale.Exact(width, height) &&
                 s_scaled.scale.HostPixels(width, height) * 4 <= s_scaled.scratchSize;
-            bool scaled = s_drawScaled && s_scaled.enabled && scaledCandidate && ScaledTextureValid(base, size);
+            // Which scaled texture this is (its cache key's surface fields):
+            // pages only a scaled texture holds are current for it alone.
+            const uint64_t sig = ScaledSignature(format, width, height, pitchAligned, uint32_t(f.endianness));
+            bool scaled = s_drawScaled && s_scaled.enabled && scaledCandidate && ScaledTextureValid(base, size, sig);
             sampler = GetSampler(f, maxLevel);
             if (out)
-                *out = { nullptr, base, size, mipBase, mipSize, scaledCandidate };
+                *out = { nullptr, base, size, mipBase, mipSize, scaledCandidate, sig };
 
             uint64_t key = scaled ? 0x5CA1ED5CA1EDull : 0xCBF29CE484222325ull;
             for (uint64_t v : { uint64_t(base), uint64_t(format), uint64_t(width), uint64_t(height), uint64_t(f.tiled),
@@ -4148,6 +4272,9 @@ void main()
                 {
                     t.width = s_scaled.scale.x.Size(width);
                     t.height = s_scaled.scale.y.Size(height);
+                    t.guestWidth = width;
+                    t.guestHeight = height;
+                    t.scaledSig = sig;
                     s_scaled.textures++;
                 }
                 // A 1x texture the untile can store directly (see
@@ -4223,6 +4350,17 @@ void main()
                             s_maxDirectSize = std::max(s_maxDirectSize, t.guestSize);
                         }
                     }
+                    else
+                    {
+                        // A scaled texture a scaled resolve can store into
+                        // as its untile would (Resolve; NFSMW_SCALED_FUSE).
+                        t.tiled = true;
+                        t.pitch = pitchAligned;
+                        t.bpbLog2 = 2;
+                        t.endian = uint32_t(f.endianness);
+                        s_scaledByStart[base] = &t;
+                        s_maxScaledSize = std::max(s_maxScaledSize, t.guestSize);
+                    }
                 }
                 if (!t.image.image)
                     t.image = CreateImage(volume ? VK_IMAGE_TYPE_3D : VK_IMAGE_TYPE_2D, fi.vk, { t.width, t.height, depth }, layers,
@@ -4451,6 +4589,7 @@ void main()
             VkImageView view = VK_NULL_HANDLE;
             VkSampler sampler = VK_NULL_HANDLE;
             uint32_t base = 0, size = 0, mipBase = 0, mipSize = 0;
+            uint64_t sig = 0;
         };
         struct TextureCache
         {
@@ -4488,7 +4627,7 @@ void main()
                 return TextureEntryState::kValid;
             // Some page was written since: the full lookup's checks, in its
             // order (its scaled copy first).
-            bool valid = !(e.scaledCandidate && drawScaled && ScaledTextureValid(e.base, e.size)) &&
+            bool valid = !(e.scaledCandidate && drawScaled && ScaledTextureValid(e.base, e.size, e.sig)) &&
                 (checked == epoch || (t.uploaded && writewatch::WriteSequence(e.base, e.size) <= t.loadedSequence &&
                     (!e.mipSize || writewatch::WriteSequence(e.mipBase, e.mipSize) <= t.loadedSequence)));
             if (!valid)
@@ -4592,6 +4731,7 @@ void main()
             e.size = lookup.size;
             e.mipBase = lookup.mipBase;
             e.mipSize = lookup.mipSize;
+            e.sig = lookup.sig;
             RecentTextureEntry(fetch, dim) = e;
             return view;
         }
@@ -4601,10 +4741,22 @@ void main()
 
         VkPipeline s_resolvePipeline = VK_NULL_HANDLE;
         VkPipeline s_resolveCoalescedPipeline = VK_NULL_HANDLE;  // scaled resolves (see COALESCED in the shader)
-        // The same for a source of another scale denominator ([coalesced][den x - 1][den y - 1]: 1.5x is 3/2), made
-        // at the first resolve that needs it (ResolvePipeline); [..][0][0] are the two above.
-        VkPipeline s_resolveDenPipelines[2][2][2] = {};
+        // The same for a source of another scale denominator ([coalesced][x][y], each den - 1, or 2 for a texel
+        // axis, a den above 2: 1.5x is 3/2, a Steam Deck's native rows 10/9), made at the first resolve that needs
+        // it (ResolvePipeline); [..][0][0] are the two above.
+        VkPipeline s_resolveDenPipelines[2][3][3] = {};
+        // Sources above 1x: the same, built with SCALED_FUSE (and TEX_OFFSET),
+        // whole scales too; [coalesced][x][y] as above.
+        VkPipeline s_resolveScaledPipelines[2][3][3] = {};
         VkPipeline ResolvePipeline(bool coalesced, const gpu::RenderScale& scale);
+        // A coalesced group's samples fit its shared memory (64 x 16 words):
+        // every scale but a texel axis's beside 4x (1x10/9 has 2 a texel,
+        // 3x10/3 12).
+        bool CoalescedFits(const gpu::RenderScale& scale)
+        {
+            const uint32_t blocks = 64 / (gpu::ScaleGlsl{}.sbLayoutDen(scale.x.den) * gpu::ScaleGlsl{}.sbLayoutDen(scale.y.den));
+            return blocks * scale.SamplesPerBlock() <= 64 * 16;
+        }
 
         // Coalesced scaled resolves: 2.8 -> 1.1 ms of scaled resolves a frame
         // on the Steam Machine (RADV), but 2.6-3.4 -> 4.1-4.4 ms on an M1 Pro
@@ -4621,12 +4773,12 @@ void main()
         // cache keeps it), 23 ms on RADV.
         void PrewarmResolvePipelines(const gpu::RenderScale& scale)
         {
-            if (scale.x.den == 1 && scale.y.den == 1)
+            if (scale.IsOne())
                 return;
             VkPhysicalDeviceProperties props;
             vkGetPhysicalDeviceProperties(s_vk->physical, &props);
             ResolvePipeline(false, scale);
-            if (ScaledCoalesce(props))
+            if (ScaledCoalesce(props) && CoalescedFits(scale))
                 ResolvePipeline(true, scale);
         }
         VkPipelineLayout s_resolveLayout = VK_NULL_HANDLE;
@@ -4644,17 +4796,28 @@ void main()
             int32_t srcOriginX, srcOriginY;  // host pixels
             uint32_t scaleX, scaleY;         // host pixels per guest pixel in the source (/ the pipeline's SB_DEN_X, SB_DEN_Y)
             uint32_t scaledWrite, slotWords; // also write the samples to the scaled memory
+            // A texel axis's (SB_TEXEL_X, SB_TEXEL_Y) denominator, and the
+            // rectangle's first pixel in the source target in guest pixels
+            // (r + the tile shift), which its host pixels count from.
+            uint32_t denX, denY;
+            int32_t srcGuestX, srcGuestY;
             // Also store into a cached direct texture (binding 4), as its
             // untile would have from the words (see Resolve); texX, texY:
             // where the destination's texel 0,0 is in it (NFSMW_FUSE_PARTIAL,
             // NFSMW_DIRECT_CUBE; pushed only with either, see s_resolvePush).
             uint32_t texWrite, texEndian, texConvert, texWidth, texHeight;
             uint32_t texX, texY;
+            // A scaled resolve's samples also into a cached scaled texture
+            // (binding 5), where its untile would have put them (see
+            // Resolve): hostX, hostY: the destination's texel 0,0 in it; its
+            // guest size and endianness. Pushed (and in the shader:
+            // SCALED_FUSE) only to the pipelines of scaled sources.
+            uint32_t hostWrite, hostX, hostY, hostWidth, hostHeight, hostEndian;
         };
         // The constants pushed to the resolve shader: without NFSMW_FUSE_PARTIAL
         // and NFSMW_DIRECT_CUBE, those before texX, as before them, and the
         // shader is built without TEX_OFFSET (the same code and push).
-        const uint32_t s_resolvePush = s_fusePartial || s_directCube ? sizeof(ResolveConstants) : offsetof(ResolveConstants, texX);
+        const uint32_t s_resolvePush = s_fusePartial || s_directCube ? offsetof(ResolveConstants, hostWrite) : offsetof(ResolveConstants, texX);
 
         const char* kResolveGlsl = R"(#version 460
 #extension GL_EXT_samplerless_texture_functions : require
@@ -4664,6 +4827,9 @@ layout(set = 0, binding = 1) uniform texture2D src;
 layout(std430, set = 0, binding = 2) buffer ScaledPool { uint s_pool[]; };
 layout(std430, set = 0, binding = 3) readonly buffer ScaledTable { uint s_table[]; };
 layout(set = 0, binding = 4, r32ui) writeonly uniform uimage2D t_image;
+#ifdef SCALED_FUSE
+layout(set = 0, binding = 5, r32ui) writeonly uniform uimage2D h_image;
+#endif
 layout(push_constant) uniform P
 {
     ivec2 origin;
@@ -4674,10 +4840,18 @@ layout(push_constant) uniform P
     ivec2 srcOrigin;    // where the rectangle is in the host target (see untiled rendering), host pixels
     uvec2 scale;        // host pixels per guest pixel (internal resolution): scale / kDen
     uint scaledWrite, slotWords;
+    uvec2 den;          // a texel axis's denominator (SB_TEXEL_X, SB_TEXEL_Y)
+    ivec2 srcGuest;     // the rectangle's first pixel in the source target, guest pixels (texel axes)
     uint texWrite, texEndian, texConvert, texWidth, texHeight;  // also into a cached texture (binding 4)
 #ifdef TEX_OFFSET
     uint texX, texY;    // the destination's texel 0,0 in it (whole tiles)
 #endif
+#ifdef SCALED_FUSE
+    // Also each host sample into a cached scaled texture (binding 5) where
+    // its untile would put it: its texel of the destination's 0,0 (whole
+    // tiles), its guest size, its endianness.
+    uint hostWrite, hostX, hostY, hostWidth, hostHeight, hostEndian;
+#endif
 } p;
 )" GLSL_SCALE_CODE R"(
 // The scale's denominators are the pipeline's own (CreateResolvePipeline: a
@@ -4691,6 +4865,29 @@ layout(push_constant) uniform P
 #define SB_DEN_Y 1u
 #endif
 const uvec2 kDen = uvec2(SB_DEN_X, SB_DEN_Y);
+// A texel axis (a den above 2, gpu/render_scale.h: a Steam Deck's native rows,
+// 10/9): its num / den from the constants and no blocks (kDen 1 there), each
+// pixel's host pixels counted from where it is in the source target
+// (srcGuest), the other axis's too. Without either the code is as before.
+#ifndef SB_TEXEL_X
+#define SB_TEXEL_X 0
+#endif
+#ifndef SB_TEXEL_Y
+#define SB_TEXEL_Y 0
+#endif
+#if SB_TEXEL_X || SB_TEXEL_Y
+#define SB_TEXEL
+// The scale as the pipeline's constants when it has them (SB_FIXED_*: a
+// texel axis's pipelines are made for their exact scale, so every division
+// by num or den is by a constant, a multiply, not a runtime division).
+#ifdef SB_FIXED_NUM_X
+uvec2 texelDen() { return uvec2(SB_FIXED_DEN_X, SB_FIXED_DEN_Y); }
+#define TEXEL_NUM uvec2(SB_FIXED_NUM_X, SB_FIXED_NUM_Y)
+#else
+uvec2 texelDen() { return uvec2(SB_TEXEL_X != 0 ? p.den.x : kDen.x, SB_TEXEL_Y != 0 ? p.den.y : kDen.y); }
+#define TEXEL_NUM p.scale
+#endif
+#endif
 
 uint tiled2D(uint x, uint y, uint pitch, uint bppLog2)
 {
@@ -4741,8 +4938,35 @@ vec4 pxFraction(uint x, uint y)
     return v;
 }
 
+#ifdef SB_TEXEL
+// px() with a texel axis: the host pixels guest pixel (x, y) of the rectangle
+// covers, from its place in the source target (srcGuest + x, y), each
+// weighted by how much of it lies inside (the box filter), or (depth) the
+// one holding its centre.
+vec4 pxTexel(uint x, uint y)
+{
+    uvec2 n = TEXEL_NUM, d = texelDen();
+    uvec2 g = uvec2(p.srcGuest) + uvec2(x, y);
+    if ((p.flags & 2u) != 0u)
+        return texelFetch(src, clamp(ivec2(sbCenterHost(g.x, n.x, d.x), sbCenterHost(g.y, n.y, d.y)), ivec2(0), ivec2(p.srcSize) - 1), 0);
+    vec4 v = vec4(0.0);
+    uint x1 = sbHostSize(g.x + 1u, n.x, d.x), y1 = sbHostSize(g.y + 1u, n.y, d.y);
+    for (uint j = g.y * n.y / d.y; j < y1; j++)
+        for (uint i = g.x * n.x / d.x; i < x1; i++)
+            v += float(sbOverlap(g.x, i, n.x, d.x) * sbOverlap(g.y, j, n.y, d.y)) *
+                texelFetch(src, clamp(ivec2(i, j), ivec2(0), ivec2(p.srcSize) - 1), 0);
+    v /= float(n.x * n.y);
+    v *= p.expScale;
+    if ((p.flags & 1u) != 0u) v = v.bgra;
+    return v;
+}
+#endif
+
 vec4 px(uint x, uint y)
 {
+#ifdef SB_TEXEL
+    return pxTexel(x, y);
+#else
     // Guest pixel (x, y) of the rectangle: its sx x sy block of host pixels,
     // averaged (colour) or its first sample (depth).
     if (kDen.x * kDen.y > 1u) return pxFraction(x, y);
@@ -4760,6 +4984,7 @@ vec4 px(uint x, uint y)
     v *= p.expScale;
     if ((p.flags & 1u) != 0u) v = v.bgra;
     return v;
+#endif
 }
 
 uint unorm(float v, float m) { return uint(clamp(v, 0.0, 1.0) * m + 0.5); }
@@ -4832,37 +5057,87 @@ void main()
         // bits 0 and 2; the rectangle's origin is even, so gx and gy agree).
         uint a = word << 2;
         uint slot = inside ? s_table[a >> 12] : 0u;
+#ifdef SB_TEXEL
+        // With a texel axis: on it, all the texel's stride of samples (the
+        // ones it owns, then its last again), from its own place in the
+        // source target; on a block axis as below, from the block's corner.
+        uvec2 n = TEXEL_NUM, d = texelDen();
+        uint sX = sbStride(n.x, d.x);
+        uint s = sX * sbStride(n.y, d.y);  // samples a block
+        uint k = (a & 4095u) >> 2;
+        uint o = (slot - 1u) * p.slotWords + sbBlockIndex(k, d.x, d.y) * s;
+        uint subX = sbSubX(k, d.x), subY = sbSubY(k, d.y);
+        uint i0 = sbSampleLo(subX, n.x, d.x), i1 = sbSampleHi(subX, n.x, d.x);
+        uint j0 = sbSampleLo(subY, n.y, d.y), j1 = sbSampleHi(subY, n.y, d.y);
+        uvec2 g = uvec2(p.srcGuest) + uvec2(gx, gy);
+#else
+        uint sX = p.scale.x;
         uint s = p.scale.x * p.scale.y;  // samples a block
         uint k = (a & 4095u) >> 2;
         uint o = (slot - 1u) * p.slotWords + sbBlockIndex(k, kDen.x, kDen.y) * s;
         uint subX = sbSubX(k, kDen.x), subY = sbSubY(k, kDen.y);
         uint i0 = sbHostEdge(subX, p.scale.x, kDen.x), i1 = sbHostEdge(subX + 1u, p.scale.x, kDen.x);
         uint j0 = sbHostEdge(subY, p.scale.y, kDen.y), j1 = sbHostEdge(subY + 1u, p.scale.y, kDen.y);
+#endif
 #ifdef COALESCED
         uint lb = sbBlockIndex(l, kDen.x, kDen.y);  // the block's in this group (l is the word order)
+#endif
+#ifdef SCALED_FUSE
+        uint tx = x + p.hostX, ty = y + p.hostY;  // the texel in the cached scaled texture
 #endif
         if (slot != 0u)
         {
+#ifndef SB_TEXEL
             ivec2 c0 = p.srcOrigin + ivec2(sbHostEdge(gx, p.scale.x, kDen.x), sbHostEdge(gy, p.scale.y, kDen.y)) - ivec2(i0, j0);
+#endif
             for (uint j = j0; j < j1; j++)
                 for (uint i = i0; i < i1; i++)
                 {
-                    vec4 v = texelFetch(src, clamp(c0 + ivec2(i, j), ivec2(0), ivec2(p.srcSize) - 1), 0);
+#ifdef SB_TEXEL
+                    ivec2 c = ivec2(sbSampleHost(g.x, subX, i, n.x, d.x), sbSampleHost(g.y, subY, j, n.y, d.y));
+#else
+                    ivec2 c = c0 + ivec2(i, j);
+#endif
+                    vec4 v = texelFetch(src, clamp(c, ivec2(0), ivec2(p.srcSize) - 1), 0);
                     if ((p.flags & 2u) == 0u)
                     {
                         v *= p.expScale;
                         if ((p.flags & 1u) != 0u) v = v.bgra;
                     }
+                    uint word32 = swapWord(pack32(v), p.endian);
 #ifdef COALESCED
-                    g_samples[lb * s + j * p.scale.x + i] = swapWord(pack32(v), p.endian);
+                    g_samples[lb * s + j * sX + i] = word32;
+#elif defined(SCALED_FUSE)
+                    if (p.hostWrite != 2u)  // (2: into the texture alone)
+                        s_pool[o + j * sX + i] = word32;
 #else
-                    s_pool[o + j * p.scale.x + i] = swapWord(pack32(v), p.endian);
+                    s_pool[o + j * sX + i] = word32;
+#endif
+#ifdef SCALED_FUSE
+                    // The texture's host texel this sample is (sbReaderHost:
+                    // the untile's own mapping; none for a texel axis's
+                    // padding), from its texel (tx, ty).
+                    if (p.hostWrite != 0u && tx < p.hostWidth && ty < p.hostHeight)
+                    {
+#ifdef SB_TEXEL
+                        uint hx = sbReaderHost(tx, subX, i, n.x, d.x), hy = sbReaderHost(ty, subY, j, n.y, d.y);
+#else
+                        uint hx = sbReaderHost(tx, subX, i, p.scale.x, kDen.x), hy = sbReaderHost(ty, subY, j, p.scale.y, kDen.y);
+#endif
+                        if (hx != ~0u && hy != ~0u)
+                            imageStore(h_image, ivec2(int(hx), int(hy)), uvec4(swapWord(word32, p.hostEndian), 0u, 0u, 0u));
+                    }
 #endif
                 }
         }
 #ifdef COALESCED
+#ifdef SCALED_FUSE
+        if (subX == 0u && subY == 0u)  // (every pixel at a whole scale; hostWrite 2: into the texture alone)
+            g_offsets[lb] = slot != 0u && p.hostWrite != 2u ? o : ~0u;
+#else
         if (subX == 0u && subY == 0u)  // (every pixel at a whole scale)
             g_offsets[lb] = slot != 0u ? o : ~0u;
+#endif
         barrier();
         uint samples = 64u / (kDen.x * kDen.y) * s;
         for (uint q = l; q < samples; q += 64u)
@@ -5482,10 +5757,16 @@ void main()
                     rc.srcOriginY = source->scale.y.EdgeAt(r.y0 + shiftY);
                     rc.scaleX = source->scale.x.num;
                     rc.scaleY = source->scale.y.num;
+                    rc.denX = source->scale.x.den;
+                    rc.denY = source->scale.y.den;
+                    rc.srcGuestX = std::max(r.x0 + shiftX, 0);
+                    rc.srcGuestY = std::max(r.y0 + shiftY, 0);
                     // At 1.5x the shader counts host pixels from srcOrigin
                     // and the destination's blocks from its origin: both
                     // need even coordinates (resolves are 8-pixel aligned
-                    // and the tile offsets even, so they are).
+                    // and the tile offsets even, so they are). A texel axis
+                    // counts each pixel from its place in the target
+                    // (srcGuest), so any origin will do (Exact).
                     const bool wholeBlocks = (r.x0 + shiftX) >= 0 && (r.y0 + shiftY) >= 0 &&
                         source->scale.x.Exact(uint32_t(r.x0 + shiftX)) && source->scale.y.Exact(uint32_t(r.y0 + shiftY)) &&
                         source->scale.x.Exact(uint32_t(r.x0)) && source->scale.y.Exact(uint32_t(r.y0));
@@ -5497,7 +5778,12 @@ void main()
                     uint32_t lastPage = std::min<uint32_t>((rangeBase + rangeBytes - 1) >> 12, kGuestPages - 1);
                     // A 32-bit resolve from a scaled target keeps its samples.
                     bool scaledWrite = !source->scale.IsOne() && wholeBlocks && bl == 2 && !destInfo.copy_dest_array &&
-                        EnsureScaledMemory() && source->scale == s_scaled.scale;
+                        EnsureScaledMemory() && source->scale == s_scaled.scale && ScaledWanted(rangeBase, rangeBytes);
+                    bool freshSlots = false;  // a page here had no current scaled copy before this
+                    // Pages whose samples only a scaled texture holds (see
+                    // below): their slots are filled from the 1x data too
+                    // unless that texture takes this resolve and keeps them.
+                    std::vector<std::pair<uint32_t, uint32_t>> heldSlots;
                     if (scaledWrite)
                     {
                         std::vector<std::pair<uint32_t, uint32_t>> fresh;
@@ -5506,14 +5792,18 @@ void main()
                             // A slot whose copy went stale (a CPU write, a 1x
                             // resolve) starts over from the 1x data too: the
                             // resolve may not cover all of it.
-                            bool stale = s_scaled.pageSlot[page] != 0 && !ScaledPageValid(page);
+                            const bool held = ScaledPageHeld(page);
+                            bool stale = s_scaled.pageSlot[page] != 0 && !ScaledPageValid(page) && !held;
                             bool isFresh;
                             uint32_t slot = ScaledSlot(page, isFresh);
                             if (isFresh || stale)
                                 fresh.push_back({ page, slot });
+                            else if (held)
+                                heldSlots.push_back({ page, slot });
                         }
                         FlushScaledTable();
                         FillFreshSlots(fresh);
+                        freshSlots = !fresh.empty();
                         rc.scaledWrite = 1;
                         rc.slotWords = s_scaled.slotWords;
                         s_scaled.resolvedBytes += s_scaled.scale.HostPixels(rc.width, rc.height) * 4;
@@ -5536,7 +5826,14 @@ void main()
                     bool partial = false;
                     uint32_t layer = 0, texX = 0, texY = 0;  // partial: the face, and the destination's texel 0,0 in it
                     // Why not (NFSMW_LOG_UPLOADS).
-                    const char* unfused = !s_resolveToTexture ? "off" : scaledWrite ? "scaled resolve" : bl != 2 ? "not 32-bit"
+                    // A scaled resolve writes the same 1x words too, so it
+                    // stores them into a 1x texture of its surface as well
+                    // (NFSMW_SCALED_FUSE=0: not, as before): the scene's depth
+                    // (a D24 texture, never scaled) and its colour where a
+                    // draw into a 1x target (the bloom chain) samples it were
+                    // loaded again every frame at native rows.
+                    const bool fuseHere = !scaledWrite || s_scaledFuse;
+                    const char* unfused = !s_resolveToTexture ? "off" : !fuseHere ? "scaled resolve" : bl != 2 ? "not 32-bit"
                         : "no direct texture there";
                     // Whether `t` can take this resolve's words as its texels at all.
                     auto unfit = [&](const Texture& t) -> const char* {
@@ -5546,7 +5843,7 @@ void main()
                             : t.offX != 0 || t.offY != 0 ? "texture offset"
                             : nullptr;
                     };
-                    if (!scaledWrite && bl == 2 && s_resolveToTexture)
+                    if (fuseHere && bl == 2 && s_resolveToTexture)
                         if (auto it = s_directByBase.find(rc.destBase); it != s_directByBase.end())
                         {
                             Texture& t = *(direct = it->second);
@@ -5559,7 +5856,7 @@ void main()
                             if (!unfused)
                                 fused = &t;
                         }
-                    if (!fused && !scaledWrite && bl == 2 && s_resolveToTexture && (s_fusePartial || s_directCube))
+                    if (!fused && fuseHere && bl == 2 && s_resolveToTexture && (s_fusePartial || s_directCube))
                     {
                         // Each direct texture holding the destination, the
                         // nearest start first, until one takes it: textures
@@ -5618,6 +5915,85 @@ void main()
                             }
                         }
                     }
+                    // A scaled resolve stores its samples into a cached scaled
+                    // texture holding its destination too, where that
+                    // texture's untile would put them (sbReaderHost), so it
+                    // stays current instead of being untiled from the pool
+                    // again before its next use: the scene, every frame. The
+                    // texture as the 1x rule above, by its first byte: this
+                    // surface's pitch, the destination whole 32x32 tiles in
+                    // and all this resolve writes inside it, nothing written
+                    // there since its load, and every page of it current in
+                    // the pool before this resolve (so its texels are the
+                    // pool's, and none of its slots is filled afresh now).
+                    // Its other texels must still be what it loaded: checked
+                    // again after MarkWritten. NFSMW_SCALED_FUSE=0: not.
+                    Texture* hosted = nullptr;
+                    const char* unhosted = !scaledWrite ? nullptr : !s_scaledFuse || !s_resolveToTexture ? "off"
+                        : freshSlots ? "fresh slots" : "no scaled texture there";
+                    uint32_t hostX = 0, hostY = 0;
+                    if (scaledWrite && s_scaledFuse && s_resolveToTexture && !freshSlots)
+                        for (auto it = s_scaledByStart.upper_bound(rc.destBase); !hosted && it != s_scaledByStart.begin();)
+                        {
+                            if (rc.destBase - (--it)->first >= s_maxScaledSize)
+                                break;
+                            Texture& t = *it->second;
+                            if (rc.destBase - t.guestStart >= t.guestSize)
+                                continue;
+                            uint32_t rel = rc.destBase - t.guestStart, tilesPerRow = std::max(t.pitch >> 5, 1u);
+                            uint32_t x = (rel >> 12) % tilesPerRow * 32, y = (rel >> 12) / tilesPerRow * 32;
+                            const char* reason = !(t.uploaded && t.storeView && t.scaled) ? "texture not loaded"
+                                : t.pitch != rc.destPitch ? "pitch differs"
+                                : rel % 4096 != 0 ? "not whole tiles into the texture"
+                                : x + uint32_t(r.x1) > rc.destPitch ? "beyond the texture's columns"
+                                : !(rangeBase >= t.guestStart && uint64_t(rangeBase) + rangeBytes <= uint64_t(t.guestStart) + t.guestSize)
+                                ? "beyond the texture"
+                                : writewatch::WrittenSince(t.guestStart, t.guestSize, t.loadedSequence) ? "texture written since its load"
+                                : !ScaledSurfaceValid(t.guestStart, t.guestSize, t.scaledSig) ? "texture's pages not all current"
+                                : nullptr;
+                            if (!reason)
+                            {
+                                hosted = &t;
+                                hostX = x;
+                                hostY = y;
+                            }
+                            unhosted = reason;
+                        }
+                    // And when no other scaled reader (another texture, the
+                    // front buffer) asked for this memory lately, the samples
+                    // go only into that texture, not the pool too: its pages
+                    // are then held by it (pageHeld), current for it alone;
+                    // any other reader sees them as 1x until a resolve
+                    // writes the pool again (one now asking makes the next
+                    // one do so). NFSMW_SCALED_HOLD=0: always the pool too.
+                    const bool hold = hosted && s_scaledHold &&
+                        !ScaledWanted(rangeBase, rangeBytes, hosted->guestStart, hosted->guestSize, hosted->scaledSig);
+                    // Held pages this resolve doesn't keep held by the same
+                    // texture: their slots start over from the 1x data, as
+                    // stale ones (the pool's copy is old).
+                    if (scaledWrite)
+                    {
+                        std::erase_if(heldSlots, [&](const std::pair<uint32_t, uint32_t>& ps) {
+                            return hold && s_scaled.pageHeld[ps.first] == hosted;
+                        });
+                        if (!heldSlots.empty())
+                        {
+                            FillFreshSlots(heldSlots);
+                            for (const auto& ps : heldSlots)
+                                s_scaled.pageHeld[ps.first] = nullptr;
+                        }
+                    }
+                    if (hosted)
+                    {
+                        rc.hostWrite = hold ? 2 : 1;
+                        rc.hostX = hostX;
+                        rc.hostY = hostY;
+                        rc.hostWidth = hosted->guestWidth;
+                        rc.hostHeight = hosted->guestHeight;
+                        rc.hostEndian = hosted->endian;
+                        LogOnce(0x2900, "scaled resolves store into cached scaled textures too (the first: %ux%u host at %08X, texels from %u,%u)",
+                            hosted->width, hosted->height, rc.destBase, hostX, hostY);
+                    }
                     if (s_uploadLog)
                     {
                         UploadLog& log = *s_uploadLog;
@@ -5629,9 +6005,11 @@ void main()
                             std::string part = !partial ? std::string()
                                 : fused->cube ? std::format(" (face {}, texels from {},{})", layer, texX, texY)
                                 : std::format(" (texels from {},{})", texX, texY);
-                            fprintf(stderr, "[upload] frame %llu resolve dest %08X range %08X+%u rect %ux%u fmt %u pitch %u %s %s%s",
+                            fprintf(stderr, "[upload] frame %llu resolve dest %08X range %08X+%u rect %ux%u fmt %u pitch %u %s %s%s%s%s",
                                 (unsigned long long)s_frame, rc.destBase, rangeBase, rangeBytes, rc.width, rc.height, format, rc.destPitch,
-                                depthSource ? "depth" : "color", fused ? "fused" : "unfused: ", fused ? part.c_str() : unfused);
+                                depthSource ? "depth" : "color", fused ? "fused" : "unfused: ", fused ? part.c_str() : unfused,
+                                !scaledWrite ? "" : hosted ? ", scaled: stored into its scaled texture" : ", scaled: not stored into a scaled texture: ",
+                                scaledWrite && !hosted ? unhosted : "");
                             std::set<std::string> kinds;
                             if (direct)
                                 fprintf(stderr, " | texture %08X+%u %ux%u pitch %u%s%s", direct->guestStart, direct->guestSize, direct->width,
@@ -5658,9 +6036,10 @@ void main()
 
                     VkDescriptorImageInfo ii{ VK_NULL_HANDLE, source->sampleView, VK_IMAGE_LAYOUT_GENERAL };
                     VkDescriptorImageInfo ti{ VK_NULL_HANDLE, fused ? fused->storeViews[layer] : s_dummyStorage.view, VK_IMAGE_LAYOUT_GENERAL };
+                    VkDescriptorImageInfo hi{ VK_NULL_HANDLE, hosted ? hosted->storeView : s_dummyStorage.view, VK_IMAGE_LAYOUT_GENERAL };
                     VkDescriptorBufferInfo pool = DummyStorage(s_scaled.pool);
                     VkDescriptorBufferInfo table = DummyStorage(s_scaled.table);
-                    VkWriteDescriptorSet w[8]{};
+                    VkWriteDescriptorSet w[9]{};
                     w[0] = { VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, nullptr, VK_NULL_HANDLE, 0, 0, 1,
                         VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, nullptr, &s_sharedInfo[0], nullptr };
                     w[1] = { VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, nullptr, VK_NULL_HANDLE, 1, 0, 1,
@@ -5671,11 +6050,14 @@ void main()
                         VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, nullptr, &table, nullptr };
                     w[4] = { VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, nullptr, VK_NULL_HANDLE, 4, 0, 1,
                         VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &ti, nullptr, nullptr };
+                    w[5] = { VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, nullptr, VK_NULL_HANDLE, 5, 0, 1,
+                        VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &hi, nullptr, nullptr };
                     s_stateEpoch++;
-                    bool coalesced = scaledWrite && s_scaled.coalesce;  // 32x2 pixels a group
+                    bool coalesced = scaledWrite && s_scaled.coalesce && CoalescedFits(source->scale);  // 32x2 pixels a group
                     vkCmdBindPipeline(s_cmd, VK_PIPELINE_BIND_POINT_COMPUTE, ResolvePipeline(coalesced, source->scale));
-                    s_pushDescriptorSet(s_cmd, VK_PIPELINE_BIND_POINT_COMPUTE, s_resolveLayout, 0, AddSharedParts(w, 5), w);
-                    vkCmdPushConstants(s_cmd, s_resolveLayout, VK_SHADER_STAGE_COMPUTE_BIT, 0, s_resolvePush, &rc);
+                    s_pushDescriptorSet(s_cmd, VK_PIPELINE_BIND_POINT_COMPUTE, s_resolveLayout, 0, AddSharedParts(w, 6), w);
+                    vkCmdPushConstants(s_cmd, s_resolveLayout, VK_SHADER_STAGE_COMPUTE_BIT, 0,
+                        source->scale.IsOne() ? s_resolvePush : uint32_t(sizeof(ResolveConstants)), &rc);
                     uint32_t perWord = bl >= 2 ? 1 : (4 >> bl);
                     if (!(s_exp & 2))
                         vkCmdDispatch(s_cmd, coalesced ? (rc.width + 31) / 32 : (rc.width / perWord + 7) / 8,
@@ -5696,7 +6078,7 @@ void main()
                         uint32_t g = s_scaled.hostPageGuestPages;
                         for (uint32_t edge : { firstPage, lastPage })
                             for (uint32_t q = edge / g * g; q < edge / g * g + g && q < kGuestPages; q++)
-                                if ((q < firstPage || q > lastPage) && ScaledPageValid(q))
+                                if ((q < firstPage || q > lastPage) && (ScaledPageValid(q) || ScaledPageHeld(q)))
                                     siblings.push_back(q);
                     }
                     uint64_t written = writewatch::MarkWritten(rangeBase, rangeBytes, writewatch::Writer::kResolve, rc.destBase);
@@ -5721,6 +6103,22 @@ void main()
                         fused->loadedSequence = written;
                         fused->verifyHashes.clear();  // (NFSMW_TEXTURE_VERIFY: its memory is the GPU's to change now)
                     }
+                    // The scaled texture likewise: current now, unless a
+                    // page of it outside this resolve was written meanwhile
+                    // (then it loads again, as without this).
+                    bool hostKept = false;
+                    if (hosted && written)
+                    {
+                        if (!partial)
+                            writewatch::Quiesce();  // (as above)
+                        if (!writewatch::WrittenSince(hosted->guestStart, rangeBase - hosted->guestStart, hosted->loadedSequence) &&
+                            !writewatch::WrittenSince(rangeEnd, hosted->guestStart + hosted->guestSize - rangeEnd, hosted->loadedSequence))
+                        {
+                            hosted->loadedSequence = written;
+                            s_scaled.hosted++;
+                            hostKept = true;
+                        }
+                    }
                     if (fused && !keep && s_uploadLog)
                     {
                         s_uploadLog->resolves[rc.destBase].unfused = "texture written outside it meanwhile";
@@ -5737,8 +6135,15 @@ void main()
                         writewatch::Watch(rangeBase, rangeBytes);
                     if (s_scaled.enabled)
                     {
+                        // Held (only the texture has this resolve's samples)
+                        // while the texture took them and stays current; a
+                        // held resolve whose texture didn't: lost (1x).
                         for (uint32_t page = firstPage; page <= lastPage; page++)
-                            s_scaled.pageSeq[page] = scaledWrite ? writewatch::WriteSequence(page << 12, 4096) : 0;
+                        {
+                            const bool lost = hold && !hostKept;
+                            s_scaled.pageSeq[page] = scaledWrite && !lost ? writewatch::WriteSequence(page << 12, 4096) : 0;
+                            s_scaled.pageHeld[page] = hold && hostKept ? hosted : nullptr;
+                        }
                         for (uint32_t q : siblings)
                             s_scaled.pageSeq[q] = writewatch::WriteSequence(q << 12, 4096);
                     }
@@ -5808,8 +6213,8 @@ layout(push_constant) uniform P { uint count, slotWords, listWord, pad; uvec2 sc
 )" GLSL_SCALE_CODE R"(
 // A new slot starts as its page's 1x data, each word in the host samples its
 // texel owns (all s at a whole scale; at 1.5x one, two or four of its
-// block's): a resolve covering the page only in part leaves no garbage
-// around it.
+// block's; on a texel axis all its stride): a resolve covering the page only
+// in part leaves no garbage around it.
 void main()
 {
     uint n = gl_GlobalInvocationID.x;
@@ -5817,12 +6222,13 @@ void main()
     if (pair >= p.count) return;
     uint page = l_pairs[p.listWord + pair * 2u], slot = l_pairs[p.listWord + pair * 2u + 1u];
     uint v = memLoad(page * 1024u + k);
-    uint o = slot * p.slotWords + sbBlockIndex(k, p.den.x, p.den.y) * (p.scale.x * p.scale.y);
+    uint sX = sbStride(p.scale.x, p.den.x);
+    uint o = slot * p.slotWords + sbBlockIndex(k, p.den.x, p.den.y) * (sX * sbStride(p.scale.y, p.den.y));
     uint subX = sbSubX(k, p.den.x), subY = sbSubY(k, p.den.y);
-    uint i1 = sbHostEdge(subX + 1u, p.scale.x, p.den.x), j1 = sbHostEdge(subY + 1u, p.scale.y, p.den.y);
-    for (uint j = sbHostEdge(subY, p.scale.y, p.den.y); j < j1; j++)
-        for (uint i = sbHostEdge(subX, p.scale.x, p.den.x); i < i1; i++)
-            s_pool[o + j * p.scale.x + i] = v;
+    uint i1 = sbSampleHi(subX, p.scale.x, p.den.x), j1 = sbSampleHi(subY, p.scale.y, p.den.y);
+    for (uint j = sbSampleLo(subY, p.scale.y, p.den.y); j < j1; j++)
+        for (uint i = sbSampleLo(subX, p.scale.x, p.den.x); i < i1; i++)
+            s_pool[o + j * sX + i] = v;
 }
 )";
         VkPipeline s_scaledFillPipeline = VK_NULL_HANDLE;
@@ -5843,7 +6249,7 @@ layout(std430, set = 0, binding = 2) writeonly buffer Out { uint o_mem[]; };
 layout(set = 0, binding = 2, r32ui) writeonly uniform uimage2D o_image;
 #endif
 // width, height: the texture's host size (whole blocks); scale / den: host
-// pixels per guest pixel.
+// pixels per guest pixel (a den above 2: a texel axis).
 layout(push_constant) uniform P { uint base, pitch, width, height, endian, slotWords; uvec2 scale, den; } p;
 )" GLSL_SCALE_CODE R"(
 uint tiled2D(uint x, uint y, uint pitch, uint bppLog2)
@@ -5871,14 +6277,15 @@ void main()
     uint w = p.width;
     if (h.x >= w || h.y >= p.height) return;
     // Host texel h: sample (h mod scale) of the block (h / scale), whose
-    // first texel is guest (block x den) (gpu/render_scale.h).
-    uvec2 b = h / p.scale;
-    uint a = (p.base + tiled2D(b.x * p.den.x, b.y * p.den.y, p.pitch, 2u)) & 0x1FFFFFFFu;
+    // first texel is guest (block x den); on a texel axis, of the texel
+    // owning it (gpu/render_scale.h).
+    uvec2 t = uvec2(sbBlockTexel(h.x, p.scale.x, p.den.x), sbBlockTexel(h.y, p.scale.y, p.den.y));
+    uint a = (p.base + tiled2D(t.x, t.y, p.pitch, 2u)) & 0x1FFFFFFFu;
     uint slot = s_table[a >> 12];
     uint v = 0u;
     if (slot != 0u)
-        v = s_pool[(slot - 1u) * p.slotWords + sbSampleWord((a & 4095u) >> 2, h.x - b.x * p.scale.x, h.y - b.y * p.scale.y,
-            p.scale.x, p.scale.y, p.den.x, p.den.y)];
+        v = s_pool[(slot - 1u) * p.slotWords + sbSampleWord((a & 4095u) >> 2, sbBlockSample(h.x, p.scale.x, p.den.x),
+            sbBlockSample(h.y, p.scale.y, p.den.y), p.scale.x, p.scale.y, p.den.x, p.den.y)];
 #ifdef TO_BUFFER
     o_mem[h.y * w + h.x] = swapWord(v, p.endian);
 #else
@@ -5928,8 +6335,47 @@ void main()
         {
             uint64_t epoch = ~0ull;
             bool valid = false;
+            uint64_t wanted = 0;  // s_frame + 1 when a scaled reader last asked for it
+            uint32_t base = 0, size = 0;
+            uint64_t sig = 0;     // the scaled texture's (ScaledSignature); 0: the front buffer
         };
         std::unordered_map<uint64_t, ScaledCheck> s_scaledChecks;
+        uint64_t ScaledCheckKey(uint32_t base, uint32_t size, uint64_t sig)
+        {
+            return ((uint64_t(base) << 32) | size) ^ (sig * 0x9E3779B97F4A7C15ull);
+        }
+
+        // Scaled resolves keep their samples only where a scaled reader (a
+        // draw into scaled targets sampling a texture there, the front
+        // buffer) asked for that memory in the last kScaledWantFrames
+        // frames; elsewhere they write the 1x words alone, as at 1x (the
+        // pages then read as 1x, as after any 1x write). The scene's depth
+        // strips (D24: never a scaled texture) and the 1x-only targets'
+        // sources were stored at host resolution every frame for no reader.
+        // A reader that starts asking reads 1x for the frame its memory
+        // takes to be resolved again. NFSMW_SCALED_WANTED=0: every scaled
+        // resolve keeps its samples, as before.
+        constexpr uint64_t kScaledWantFrames = 120;
+        const bool s_scaledWantedOnly = [] { const char* v = std::getenv("NFSMW_SCALED_WANTED"); return !v || v[0] != '0'; }();
+        // (`except`: a scaled texture's surface not to count, ScaledSignature.)
+        bool ScaledWanted(uint32_t base, uint32_t size, uint32_t exceptBase, uint32_t exceptSize, uint64_t exceptSig)
+        {
+            for (const auto& [key, check] : s_scaledChecks)
+            {
+                if (!check.wanted || check.wanted + kScaledWantFrames <= s_frame + 1)
+                    continue;
+                if (exceptSig && check.sig == exceptSig && check.base == exceptBase && check.size == exceptSize)
+                    continue;
+                const uint64_t b = check.base, e = b + check.size;
+                if (b < uint64_t(base) + size && uint64_t(base) < e)
+                    return true;
+            }
+            return false;
+        }
+        bool ScaledWanted(uint32_t base, uint32_t size)
+        {
+            return !s_scaledWantedOnly || ScaledWanted(base, size, 0, 0, 0);
+        }
 
         // The pool, page table and scratch buffer (the caller has the GPU idle).
         void FreeScaledBuffers()
@@ -5963,6 +6409,7 @@ void main()
             s_scaled.scratchSize = 0;
             std::vector<uint32_t>().swap(s_scaled.pageSlot);
             std::vector<uint64_t>().swap(s_scaled.pageSeq);
+            std::vector<const void*>().swap(s_scaled.pageHeld);
             std::vector<uint32_t>().swap(s_scaled.slotPage);
             std::vector<uint8_t>().swap(s_scaled.slotRef);
             s_scaled.dirty.clear();
@@ -5984,14 +6431,28 @@ void main()
                 return false;
             VkPhysicalDeviceProperties props;
             vkGetPhysicalDeviceProperties(s_vk->physical, &props);
-            uint64_t megabytes = 512;
+            // gpu::ScaledPoolMegabytes: 512 MB on a discrete GPU, 128 MB at a
+            // Steam Deck's native rows (1x10/9: 512 MB took ~510 MB more VRAM
+            // than 1x, and 128 MB the same GPU time, 450 MB less).
+            uint64_t megabytes = gpu::ScaledPoolMegabytes(s_scaled.scale, props.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU);
             if (const char* v = std::getenv("NFSMW_SCALED_MB"))
                 megabytes = std::clamp<uint64_t>(std::strtoull(v, nullptr, 10), 16, 4096);
-            // The whole budget, whatever the scale: kept across live changes
-            // of the internal resolution (ResetScaledMemory). Bound whole, so
-            // within the device's storage buffer range (NFSMW_SCALED_MB=4096
-            // is past a 4 GB - 1 limit).
+            // Kept across live changes of the internal resolution
+            // (ResetScaledMemory), and made again larger for a scale that
+            // wants more (below). Bound whole, so within the device's storage
+            // buffer range (NFSMW_SCALED_MB=4096 is past a 4 GB - 1 limit).
             VkDeviceSize poolSize = std::min<VkDeviceSize>(VkDeviceSize(megabytes) << 20, props.limits.maxStorageBufferRange) & ~VkDeviceSize(0xFFFF);
+            if (s_scaled.pool && s_scaled.poolBytes < poolSize)
+            {
+                // (Commands in flight may still bind it, as a stand-in too.)
+                Flush();
+                video::WaitGpuIdle();
+                vkDestroyBuffer(s_dev, s_scaled.pool, nullptr);
+                vkFreeMemory(s_dev, s_scaled.poolMemory, nullptr);
+                s_scaled.pool = VK_NULL_HANDLE;
+                s_scaled.poolMemory = VK_NULL_HANDLE;
+                s_scaled.poolBytes = 0;
+            }
             s_scaled.slotWords = s_scaled.scale.SlotWords();
             s_scaled.slots = uint32_t(std::min<uint64_t>(poolSize / (4ull * s_scaled.slotWords), kGuestPages));
             // Scaled textures up to 1280x1024 (at scale). The untile stores
@@ -6041,6 +6502,7 @@ void main()
             }
             s_scaled.pageSlot.assign(kGuestPages, 0);
             s_scaled.pageSeq.assign(kGuestPages, 0);
+            s_scaled.pageHeld.assign(kGuestPages, nullptr);
             s_scaled.slotPage.assign(s_scaled.slots, 0);
             s_scaled.slotRef.assign(s_scaled.slots, 0);
             long hostPage = sysconf(_SC_PAGESIZE);
@@ -6081,14 +6543,18 @@ void main()
             return true;
         }
 
-        bool ScaledTextureValid(uint32_t base, uint32_t size)
+        bool ScaledTextureValid(uint32_t base, uint32_t size, uint64_t sig)
         {
             uint64_t epoch = writewatch::WriteEpoch();
-            ScaledCheck& check = s_scaledChecks[(uint64_t(base) << 32) | size];
+            ScaledCheck& check = s_scaledChecks[ScaledCheckKey(base, size, sig)];
+            check.base = base;
+            check.size = size;
+            check.sig = sig;
+            check.wanted = s_frame + 1;
             if (check.epoch != epoch)
             {
                 check.epoch = epoch;
-                check.valid = ScaledRangeValid(base, size);
+                check.valid = ScaledSurfaceValid(base, size, sig);
                 if (!check.valid)
                     s_scaled.fallbacks++;
             }
@@ -6217,12 +6683,20 @@ void main()
     if (p.scaled != 0u)
     {
         // Host pixel g: sample (g mod scale) of the block (g / scale), whose
-        // first texel is guest (block x den) (gpu/render_scale.h).
-        uint bx = g.x / p.sx, by = g.y / p.sy;
-        uint a = (p.base + tiled2D(bx * p.denX, by * p.denY, p.pitch, 2u)) & 0x1FFFFFFFu;
+        // first texel is guest (block x den); on a texel axis, of the texel
+        // owning it (gpu/render_scale.h).
+        // (SB_FIXED_*: the scale as constants, a pipeline made for it: no
+        // runtime divisions, see the resolve shader.)
+#ifdef SB_FIXED_NUM_X
+        const uint sx = SB_FIXED_NUM_X, sy = SB_FIXED_NUM_Y, denX = SB_FIXED_DEN_X, denY = SB_FIXED_DEN_Y;
+#else
+        uint sx = p.sx, sy = p.sy, denX = p.denX, denY = p.denY;
+#endif
+        uint tx = sbBlockTexel(g.x, sx, denX), ty = sbBlockTexel(g.y, sy, denY);
+        uint a = (p.base + tiled2D(tx, ty, p.pitch, 2u)) & 0x1FFFFFFFu;
         uint slot = s_table[a >> 12];
-        v = slot != 0u ? s_pool[(slot - 1u) * p.slotWords + sbSampleWord((a & 4095u) >> 2, g.x - bx * p.sx, g.y - by * p.sy, p.sx, p.sy,
-            p.denX, p.denY)] : 0u;
+        v = slot != 0u ? s_pool[(slot - 1u) * p.slotWords + sbSampleWord((a & 4095u) >> 2, sbBlockSample(g.x, sx, denX),
+            sbBlockSample(g.y, sy, denY), sx, sy, denX, denY)] : 0u;
     }
     else
     {
@@ -6251,6 +6725,13 @@ void main()
         VkPipeline s_frontPipeline = VK_NULL_HANDLE;
         VkPipelineLayout s_frontLayout = VK_NULL_HANDLE;
         VkDescriptorSetLayout s_frontSetLayout = VK_NULL_HANDLE;
+        // The same for a texel axis's scale, made for that exact scale
+        // (SB_FIXED_*) at its first scaled present (Steam Deck 1x10/9: the
+        // divisions by the push constants were most of the front's cost).
+        VkPipeline s_frontFixedPipeline = VK_NULL_HANDLE;
+        VkPipelineLayout s_frontFixedLayout = VK_NULL_HANDLE;
+        VkDescriptorSetLayout s_frontFixedSetLayout = VK_NULL_HANDLE;
+        gpu::RenderScale s_frontFixedScale;
         // The front buffer as presented: 1x, and at host resolution when the
         // scaled resolve memory has it (two images: no stall when the game
         // switches between them, e.g. around movies).
@@ -6289,16 +6770,28 @@ void main()
         }
 
         // The resolve shader for sources whose scale has these denominators
-        // (1 or 2 each; the shader's SB_DEN_X, SB_DEN_Y), into `out`.
-        void MakeResolvePipeline(bool coalesced, uint32_t denX, uint32_t denY, VkPipeline* out)
+        // (1 or 2 each; the shader's SB_DEN_X, SB_DEN_Y; 0 for a texel axis,
+        // SB_TEXEL_X, SB_TEXEL_Y: any den above 2, from the constants), into
+        // `out`.
+        void MakeResolvePipeline(bool coalesced, uint32_t denX, uint32_t denY, VkPipeline* out, bool scaled = false,
+            const gpu::RenderScale* fixed = nullptr)
         {
             std::string log;
             std::string preamble = coalesced ? "#define COALESCED\n" : "";
-            if (s_resolvePush != offsetof(ResolveConstants, texX))
+            if (fixed)
+                preamble += std::format("#define SB_FIXED_NUM_X {}u\n#define SB_FIXED_DEN_X {}u\n#define SB_FIXED_NUM_Y {}u\n#define SB_FIXED_DEN_Y {}u\n",
+                    fixed->x.num, fixed->x.den, fixed->y.num, fixed->y.den);
+            if (s_resolvePush != offsetof(ResolveConstants, texX) || scaled)
                 preamble += "#define TEX_OFFSET\n";
-            if (denX != 1)
+            if (scaled)
+                preamble += "#define SCALED_FUSE\n";
+            if (denX == 0)
+                preamble += "#define SB_TEXEL_X 1\n";
+            else if (denX != 1)
                 preamble += std::format("#define SB_DEN_X {}u\n", denX);
-            if (denY != 1)
+            if (denY == 0)
+                preamble += "#define SB_TEXEL_Y 1\n";
+            else if (denY != 1)
                 preamble += std::format("#define SB_DEN_Y {}u\n", denY);
             auto spirv = CompileGlsl(kResolveGlsl, GLSLANG_STAGE_COMPUTE, log, preamble);
             if (spirv.empty())
@@ -6317,34 +6810,44 @@ void main()
         // The resolve pipeline for a source at `scale` (see s_resolveDenPipelines).
         VkPipeline ResolvePipeline(bool coalesced, const gpu::RenderScale& scale)
         {
-            const uint32_t dx = std::clamp(scale.x.den, 1u, 2u), dy = std::clamp(scale.y.den, 1u, 2u);
-            VkPipeline& slot = s_resolveDenPipelines[coalesced][dx - 1][dy - 1];
+            // (0: a texel axis, any den above 2.)
+            const uint32_t dx = scale.x.Texel() ? 0 : std::clamp(scale.x.den, 1u, 2u), dy = scale.y.Texel() ? 0 : std::clamp(scale.y.den, 1u, 2u);
+            const bool scaled = !scale.IsOne();
+            // A texel axis's: one for its exact scale (SB_FIXED_*), kept per
+            // scale (a live change to another makes its own).
+            const bool fixed = scaled && (dx == 0 || dy == 0);
+            static std::map<std::tuple<bool, uint32_t, uint32_t, uint32_t, uint32_t>, VkPipeline> s_fixedPipelines;
+            VkPipeline& slot = fixed ? s_fixedPipelines[{ coalesced, scale.x.num, scale.x.den, scale.y.num, scale.y.den }]
+                : (scaled ? s_resolveScaledPipelines : s_resolveDenPipelines)[coalesced][dx == 0 ? 2 : dx - 1][dy == 0 ? 2 : dy - 1];
             if (!slot)
             {
                 auto start = std::chrono::steady_clock::now();
-                MakeResolvePipeline(coalesced, dx, dy, &slot);
-                fprintf(stderr, "[renderer] resolve pipeline for scale denominators %ux%u%s made (%.1f ms)\n", dx, dy,
-                    coalesced ? ", coalesced" : "", std::chrono::duration<double, std::milli>(std::chrono::steady_clock::now() - start).count());
+                MakeResolvePipeline(coalesced, dx, dy, &slot, scaled, fixed ? &scale : nullptr);
+                fprintf(stderr, "[renderer] resolve pipeline for scale denominators %sx%s%s%s made (%.1f ms)\n",
+                    dx ? std::to_string(dx).c_str() : "texel", dy ? std::to_string(dy).c_str() : "texel", coalesced ? ", coalesced" : "",
+                    scaled ? ", scaled source" : "",
+                    std::chrono::duration<double, std::milli>(std::chrono::steady_clock::now() - start).count());
             }
             return slot;
         }
 
         void CreateResolvePipeline()
         {
-            VkDescriptorSetLayoutBinding b[5] = {
+            VkDescriptorSetLayoutBinding b[6] = {
                 { 0, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr },
                 { 1, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr },
                 { 2, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr },  // scaled pool
                 { 3, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr },  // scaled page table
                 { 4, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr },   // a cached texture (or a dummy)
+                { 5, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr },   // a cached scaled texture (or a dummy)
             };
-            auto bindings = WithSharedParts(b, 5);
+            auto bindings = WithSharedParts(b, 6);
             VkDescriptorSetLayoutCreateInfo dslci{ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO };
             dslci.flags = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR;
             dslci.bindingCount = uint32_t(bindings.size());
             dslci.pBindings = bindings.data();
             Check(vkCreateDescriptorSetLayout(s_dev, &dslci, nullptr, &s_resolveSetLayout), "resolve set layout");
-            VkPushConstantRange range{ VK_SHADER_STAGE_COMPUTE_BIT, 0, s_resolvePush };
+            VkPushConstantRange range{ VK_SHADER_STAGE_COMPUTE_BIT, 0, uint32_t(sizeof(ResolveConstants)) };
             VkPipelineLayoutCreateInfo plci{ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO };
             plci.setLayoutCount = 1;
             plci.pSetLayouts = &s_resolveSetLayout;
@@ -6367,6 +6870,7 @@ void main()
         memplan::Memory s_planMemory;  // the plan's view of the device's memory
         uint32_t s_guestType = memplan::kNoType;  // the copy's memory type (kNoType: imported)
         std::string s_guestChoice;  // for the [renderer] memory line
+        memplan::Gpu s_planGpu = memplan::Gpu::kOther;  // the kind the memory was planned for (memplan::OverPcieNote)
 
         // Test hooks for the plan's fallbacks, which the machines we test on
         // never need:
@@ -6634,6 +7138,7 @@ void main()
             VkMemoryRequirements req;
             VkBuffer copy = NewCopyBuffer(req);
             in.bits = req.memoryTypeBits;
+            s_planGpu = in.gpu;
             memplan::Plan plan = memplan::PlanGuestMemory(s_planMemory, in);
             std::string failed;
             const memplan::Candidate* placed = nullptr;
@@ -6723,6 +7228,10 @@ void main()
             fprintf(stderr, "[renderer] memory: guest memory %s; upload ring in %s, memory type %u (%s)%s\n", s_guestChoice.c_str(),
                 placed->place == memplan::Place::kVram ? "CPU-mapped VRAM" : placed->place == memplan::Place::kCached ? "cached host memory"
                     : "host memory", placed->type, plan.why.c_str(), AfterFailed(failed).c_str());
+            // Issue #40: say so when the GPU reads guest memory across PCIe.
+            if (const char* note = memplan::OverPcieNote(s_planGpu, s_shadowMode && s_shadowInVram,
+                    (s_memProps.memoryTypes[placed->type].propertyFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0))
+                fprintf(stderr, "[renderer] note: %s\n", note);
         }
 
         void CreateSet0()
@@ -6810,10 +7319,11 @@ void main()
         //     presenter's AA image with them.
         //   - Mipmaps: the whole texture cache, each texture loaded again
         //     from guest memory when a draw next uses it.
-        // Auto follows the picture's size (the window, fullscreen, Aspect
-        // Ratio) once it has held for kAutoSettleFrames, so a window being
-        // dragged doesn't rebuild at every step; a change of the setting
-        // itself applies at the next swap.
+        // Auto, and a setting's native rows or columns (video::NativeShape),
+        // follow the picture's size (the window, fullscreen, Aspect Ratio)
+        // once it has held for kAutoSettleFrames, so a window being dragged
+        // doesn't rebuild at every step; a change of the setting itself
+        // applies at the next swap.
         uint64_t s_liveGeneration = ~0ull;
         int32_t s_resolutionSetting = 0;  // Internal Resolution as applied
         constexpr uint32_t kAutoSettleFrames = 30;
@@ -6826,6 +7336,10 @@ void main()
                 s_directByBase.erase(it);
             if (auto it = s_directByStart.find(t.guestStart); it != s_directByStart.end() && it->second == &t)
                 s_directByStart.erase(it);
+            if (auto it = s_scaledByStart.find(t.guestStart); it != s_scaledByStart.end() && it->second == &t)
+                s_scaledByStart.erase(it);
+            if (t.scaled)
+                ReleaseHeldPages(&t, t.guestStart, t.guestSize);
             for (auto& [swizzle, view] : t.views)
                 vkDestroyImageView(s_dev, view, nullptr);
             t.views.clear();
@@ -6931,7 +7445,8 @@ void main()
                 return;
             int32_t setting = settings::GetInt(settings::Id::InternalResolution);
             uint32_t regionW = 0, regionH = 0;
-            if (setting <= 0)
+            // Auto, and a setting's native rows or columns, follow the picture.
+            if (setting <= 0 || s_nativeShape)
             {
                 video::FrameRegion(regionW, regionH);
                 if (regionW == 0 || regionH == 0)
@@ -6944,7 +7459,8 @@ void main()
                 s_autoSeen = 0;
                 return;
             }
-            // Only the picture's size moved (Auto): once it has settled.
+            // Only the picture's size moved (Auto, native rows or columns):
+            // once it has settled.
             if (setting == s_resolutionSetting)
             {
                 if (!(want == s_autoWant))
@@ -9517,6 +10033,13 @@ void main()
         // At host resolution when a scaled resolve wrote it (the game's frames;
         // movies and loading screens drawn at 1x use the 1x image). At 1.5x
         // only a front buffer of whole blocks (even; 1280x720 is).
+        if (pc.tiled && !showTexture[0] && s_scaled.enabled)
+        {
+            ScaledCheck& check = s_scaledChecks[ScaledCheckKey(pc.base, frontBytes, 0)];  // (ScaledWanted)
+            check.base = pc.base;
+            check.size = frontBytes;
+            check.wanted = s_frame + 1;
+        }
         bool scaled = pc.tiled && !showTexture[0] && s_scaled.enabled && s_scaled.scale.Exact(width, height) &&
             ScaledRangeValid(pc.base, frontBytes);
         uint32_t outW = scaled ? s_scaled.scale.x.Size(width) : width, outH = scaled ? s_scaled.scale.y.Size(height) : height;
@@ -9564,9 +10087,28 @@ void main()
             { VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, nullptr, VK_NULL_HANDLE, 3, 0, 1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, nullptr, &table, nullptr },
         };
         s_stateEpoch++;
-        vkCmdBindPipeline(s_cmd, VK_PIPELINE_BIND_POINT_COMPUTE, s_frontPipeline);
-        s_pushDescriptorSet(s_cmd, VK_PIPELINE_BIND_POINT_COMPUTE, s_frontLayout, 0, AddSharedParts(w, 4), w);
-        vkCmdPushConstants(s_cmd, s_frontLayout, VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(pc), &pc);
+        const bool fixedFront = scaled && (s_scaled.scale.x.Texel() || s_scaled.scale.y.Texel());
+        if (fixedFront && !(s_frontFixedPipeline && s_frontFixedScale == s_scaled.scale))
+        {
+            // (A live change's old one may still be in flight: kept, not destroyed. Rare.)
+            VkDescriptorSetLayoutBinding fb[4] = {
+                { 0, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr },
+                { 1, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr },
+                { 2, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr },
+                { 3, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr },
+            };
+            auto bindings = WithSharedParts(fb, 4);
+            const gpu::RenderScale& sc = s_scaled.scale;
+            CreateComputePipeline(kFrontGlsl, bindings.data(), uint32_t(bindings.size()), 14 * sizeof(uint32_t), s_frontFixedSetLayout,
+                s_frontFixedLayout, s_frontFixedPipeline,
+                std::format("#define SB_FIXED_NUM_X {}u\n#define SB_FIXED_DEN_X {}u\n#define SB_FIXED_NUM_Y {}u\n#define SB_FIXED_DEN_Y {}u\n",
+                    sc.x.num, sc.x.den, sc.y.num, sc.y.den).c_str());
+            s_frontFixedScale = sc;
+        }
+        VkPipelineLayout frontLayout = fixedFront ? s_frontFixedLayout : s_frontLayout;
+        vkCmdBindPipeline(s_cmd, VK_PIPELINE_BIND_POINT_COMPUTE, fixedFront ? s_frontFixedPipeline : s_frontPipeline);
+        s_pushDescriptorSet(s_cmd, VK_PIPELINE_BIND_POINT_COMPUTE, frontLayout, 0, AddSharedParts(w, 4), w);
+        vkCmdPushConstants(s_cmd, frontLayout, VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(pc), &pc);
         vkCmdDispatch(s_cmd, (outW + 7) / 8, (outH + 7) / 8, 1);
         GuardGpu(pc.base, frontBytes, false, "front buffer");
         FullBarrier();
@@ -10052,7 +10594,7 @@ void main()
     ScaledStats GetScaledStats()
     {
         return { s_scaled.loads, s_scaled.untiledBytes, s_scaled.resolvedBytes, s_scaled.allocations, s_scaled.evictions,
-            s_scaled.fallbacks };
+            s_scaled.fallbacks, s_scaled.hosted };
     }
 
     Stats GetStats()
diff --git a/runtime/gpu/renderer.h b/runtime/gpu/renderer.h
index 78f4387..47927fc 100644
--- a/runtime/gpu/renderer.h
+++ b/runtime/gpu/renderer.h
@@ -103,6 +103,7 @@ namespace gpu::renderer
     struct ScaledStats
     {
         uint64_t loads, untiledBytes, resolvedBytes, allocations, evictions, fallbacks;
+        uint64_t hosted;  // scaled resolves that also stored into their scaled texture (no load needed)
     };
     ScaledStats GetScaledStats();
     // Device memory held now, in bytes: the renderer's render targets,
diff --git a/runtime/hid/input.cpp b/runtime/hid/input.cpp
index 3e468db..179030f 100644
--- a/runtime/hid/input.cpp
+++ b/runtime/hid/input.cpp
@@ -4,6 +4,7 @@
 #include "input.h"
 #include "key_map.h"
 #include "player_slots.h"
+#include "rumble_note.h"
 #include "wheel.h"
 #include <cpu/guest_time.h>
 #include <game/split_screen.h>
@@ -613,6 +614,60 @@ namespace
             SDL_UpdateJoysticks();  // read back this frame
     }
 
+    // The "no rumble over USB" note (hid/rumble_note.h): player 1's
+    // controller as SDL reaches it, judged by Update once the note can show.
+    struct RumbleNotePad
+    {
+        SDL_Gamepad* gamepad = nullptr;  // pending for this pad; null when decided
+        char driver = 0;
+        hid::RumbleNote::Connection connection = hid::RumbleNote::Connection::Unknown;
+        uint16_t vendor = 0;
+        std::string name;
+    };
+    RumbleNotePad s_rumbleNotePad;
+
+    // Main thread, from Update: the note, shown or skipped, with a line
+    // either way; it waits (silently) for the UI, no other panel, and the
+    // controls idle 3 s (not mid-race), as the refresh-rate notice does.
+    void MaybeRumbleNote(bool vibration)
+    {
+        using Note = hid::RumbleNote;
+        RumbleNotePad& pad = s_rumbleNotePad;
+        if (!pad.gamepad)
+            return;
+        if (pad.gamepad != s_gamepad)
+        {
+            pad.gamepad = nullptr;  // gone before it was judged (the next one is judged on its own)
+            return;
+        }
+        Note::Inputs in;
+#if defined(__APPLE__) && !TARGET_OS_IOS
+        in.platform = Note::Platform::Mac;
+#endif
+        in.driver = pad.driver;
+        in.connection = pad.connection;
+        in.vendor = pad.vendor;
+        in.name = pad.name;
+        in.vibration = vibration;
+        in.shownBefore = settings::RumbleNoteShown();
+        const Note::Decision d = Note::Decide(in);
+        if (!d.show)
+        {
+            pad.gamepad = nullptr;
+            fprintf(stderr, "[input] rumble note for %s: not shown: %s\n", pad.name.c_str(), d.reason);
+            return;
+        }
+        if (!ui::Ready() || ui::HasModal() || ui::SettingsOpen() || hid::SecondsSinceInput() < 3.0)
+            return;
+        if (!ui::ShowNotice(Note::kTitle, Note::kText, [](const char*) {
+                if (settings::RecordRumbleNote())
+                    fprintf(stderr, "[input] rumble note: recorded in settings.toml (not shown again)\n");
+            }))
+            return;
+        pad.gamepad = nullptr;
+        fprintf(stderr, "[input] rumble note for %s: shown (%s)\n", pad.name.c_str(), d.reason);
+    }
+
     void OpenFirstGamepad()
     {
         if (s_gamepad)
@@ -651,9 +706,26 @@ namespace
             {
                 // What it can do: a pad without motors takes rumble and ignores it.
                 SDL_PropertiesID props = SDL_GetGamepadProperties(s_gamepad);
-                fprintf(stderr, "[input] gamepad: %s (rumble %s, trigger rumble %s)\n", SDL_GetGamepadName(s_gamepad),
+                // How SDL reaches it (a wired Xbox Series pad on a Mac takes no rumble while the
+                // same pad over Bluetooth does): the GUID's driver byte ('h' HIDAPI, 'm' Apple's GameController,
+                // 0 the system's HID), the connection and the device path.
+                SDL_GUID guid = SDL_GetJoystickGUID(SDL_GetGamepadJoystick(s_gamepad));
+                char guidText[33];
+                SDL_GUIDToString(guid, guidText, sizeof(guidText));
+                const char* path = SDL_GetGamepadPath(s_gamepad);
+                SDL_JoystickConnectionState conn = SDL_GetGamepadConnectionState(s_gamepad);
+                fprintf(stderr, "[input] gamepad: %s (rumble %s, trigger rumble %s; %s, driver '%c', guid %s, path %s)\n",
+                    SDL_GetGamepadName(s_gamepad),
                     SDL_GetBooleanProperty(props, SDL_PROP_GAMEPAD_CAP_RUMBLE_BOOLEAN, false) ? "yes" : "no",
-                    SDL_GetBooleanProperty(props, SDL_PROP_GAMEPAD_CAP_TRIGGER_RUMBLE_BOOLEAN, false) ? "yes" : "no");
+                    SDL_GetBooleanProperty(props, SDL_PROP_GAMEPAD_CAP_TRIGGER_RUMBLE_BOOLEAN, false) ? "yes" : "no",
+                    conn == SDL_JOYSTICK_CONNECTION_WIRED ? "wired" : conn == SDL_JOYSTICK_CONNECTION_WIRELESS ? "wireless" : "connection unknown",
+                    guid.data[14] ? char(guid.data[14]) : '0', guidText, path ? path : "none");
+                const char* name = SDL_GetGamepadName(s_gamepad);
+                s_rumbleNotePad = { s_gamepad, char(guid.data[14]),
+                    conn == SDL_JOYSTICK_CONNECTION_WIRED ? hid::RumbleNote::Connection::Wired
+                        : conn == SDL_JOYSTICK_CONNECTION_WIRELESS ? hid::RumbleNote::Connection::Wireless
+                        : hid::RumbleNote::Connection::Unknown,
+                    SDL_GetGamepadVendor(s_gamepad), name ? name : "" };
             }
             break;
         }
@@ -1247,10 +1319,19 @@ namespace hid
                     vibration ? "on" : "off (the controller gets 0)", s_gamepad ? "" : "; no controller");
             }
         }
+        MaybeRumbleNote(vibration);
         if (!vibration)
             low = high = 0;
-        if (rumble && s_gamepad)
-            SDL_RumbleGamepad(s_gamepad, low, high, low || high ? 5000 : 0);
+        if (rumble && s_gamepad && !SDL_RumbleGamepad(s_gamepad, low, high, low || high ? 5000 : 0))
+        {
+            // A pad that says it has motors but refuses them: once per session, with SDL's reason.
+            static bool told = false;
+            if (!told)
+            {
+                told = true;
+                fprintf(stderr, "[input] rumble refused by %s: %s\n", SDL_GetGamepadName(s_gamepad), SDL_GetError());
+            }
+        }
         // The wheel's own force feedback: every frame, since Settings >
         // Wheel > Force Feedback and Centering Force can change under it
         // without the game asking for anything new.
diff --git a/runtime/hid/rumble_note.h b/runtime/hid/rumble_note.h
new file mode 100644
index 0000000..87e713b
--- /dev/null
+++ b/runtime/hid/rumble_note.h
@@ -0,0 +1,101 @@
+// SpeedBreaker runtime. GPL-3.0-or-later (see COPYING).
+//
+// The one-time note that an Xbox controller connected by USB to a Mac takes
+// no rumble. macOS hands a wired Xbox One/Series pad to SDL through Apple's
+// GameController framework (the GUID's driver byte 'm', connection unknown),
+// whose haptics accept every call and buzz nothing (a standalone CoreHaptics
+// test: every call "ok", no motor); over Bluetooth the same pad goes through
+// SDL's HIDAPI ('h') and rumbles, and a DualSense rumbles either way.
+// Nothing the game can do about it, so it says so once. When it shows;
+// hid/input.cpp feeds it and ui::ShowNotice draws it. Header only:
+// tests/rumble_note_test.cpp checks it.
+//
+// Shown when, all at once:
+//   - on macOS (not iOS, Windows or Linux);
+//   - player 1's controller is an Xbox one (USB vendor 0x045E, Microsoft, or
+//     "Xbox" in its name: a licensed pad from another maker);
+//   - SDL reaches it through Apple's GameController framework (driver 'm');
+//   - it isn't reported wireless (wired or unknown: GameController reports
+//     no connection);
+//   - Settings > Input > Vibration is on (off, there is nothing to miss);
+//   - not dismissed before (settings.toml's [app] xbox_usb_rumble_note).
+// The game pauses under it, as for the refresh-rate notice; A, B, Start, Esc
+// or OK closes it, and it is recorded then.
+#pragma once
+#include <cctype>
+#include <cstdint>
+#include <string_view>
+
+namespace hid
+{
+    struct RumbleNote
+    {
+        enum class Platform
+        {
+            Mac,
+            Other,  // iOS, Windows, Linux
+        };
+        enum class Connection
+        {
+            Unknown,
+            Wired,
+            Wireless,
+        };
+
+        struct Inputs
+        {
+            Platform platform = Platform::Other;
+            char driver = 0;  // the SDL GUID's driver byte: 'h' HIDAPI, 'm' GameController, 0 the system's HID
+            Connection connection = Connection::Unknown;
+            uint16_t vendor = 0;  // the USB vendor id (0 unknown)
+            std::string_view name;
+            bool vibration = true;     // Settings > Input > Vibration
+            bool shownBefore = false;  // settings.toml's [app] xbox_usb_rumble_note
+        };
+
+        struct Decision
+        {
+            bool show;
+            const char* reason;  // why (not), for the log
+        };
+
+        static constexpr uint16_t kMicrosoft = 0x045E;
+        static constexpr const char* kTitle = "No rumble over USB";
+        static constexpr const char* kText =
+            "Rumble doesn't work with Xbox controllers connected by USB on a Mac. "
+            "Pair it over Bluetooth for rumble.";
+
+        static bool IsXbox(uint16_t vendor, std::string_view name)
+        {
+            if (vendor == kMicrosoft)
+                return true;
+            constexpr std::string_view xbox = "xbox";
+            for (size_t i = 0; i + xbox.size() <= name.size(); i++)
+            {
+                size_t k = 0;
+                while (k < xbox.size() && std::tolower(uint8_t(name[i + k])) == xbox[k])
+                    k++;
+                if (k == xbox.size())
+                    return true;
+            }
+            return false;
+        }
+
+        static Decision Decide(const Inputs& in)
+        {
+            if (in.platform != Platform::Mac)
+                return { false, "not macOS" };
+            if (!IsXbox(in.vendor, in.name))
+                return { false, "not an Xbox controller" };
+            if (in.driver != 'm')
+                return { false, "not through Apple's GameController (this route rumbles)" };
+            if (in.connection == Connection::Wireless)
+                return { false, "wireless" };
+            if (!in.vibration)
+                return { false, "Vibration is off" };
+            if (in.shownBefore)
+                return { false, "dismissed before (settings.toml [app] xbox_usb_rumble_note)" };
+            return { true, "an Xbox controller by USB through Apple's GameController, Vibration on" };
+        }
+    };
+}
diff --git a/runtime/ui/settings_menu.cpp b/runtime/ui/settings_menu.cpp
index 8657621..74b0162 100644
--- a/runtime/ui/settings_menu.cpp
+++ b/runtime/ui/settings_menu.cpp
@@ -13,6 +13,7 @@
 #include "ui.h"
 #include "quit_game.h"
 
+#include <game/language.h>  // the Language row's note: what the installed files give
 #include <report/report.h>
 #include <user/settings.h>
 #include <hid/key_map.h>     // the Controls page: one row per control, two keys each
@@ -94,6 +95,8 @@ namespace ui
         {
             if (c == Category::Wheel)
                 return hid::wheel::Found();
+            if (c == Category::Game)  // its one row, Language, isn't shown on iPhone and iPad
+                return !settings::Info(Id::GameLanguage).hidden;
 #if defined(__APPLE__) && TARGET_OS_IOS
             if (c == Category::Controls)
                 return SDL_HasKeyboard();
@@ -780,6 +783,29 @@ namespace ui
                     video::WindowFullscreen() ? "fullscreen" : "windowed", settings::GetBool(Id::Fullscreen) ? "fullscreen" : "windowed");
                 return;
             }
+            // Language: what the installed files give the language chosen
+            // here (the one this run has, under NFSMW_LANGUAGE), then when
+            // it applies.
+            if (o.id == Id::GameLanguage)
+            {
+                const char* env = settings::EnvOverride(o.id);
+                const double value = env ? settings::GetValue(o.id) : settings::GetStoredValue(o.id);
+                ImGui::PushStyleColor(ImGuiCol_Text, ImGui::GetStyleColorVec4(ImGuiCol_TextDisabled));
+                ImGui::TextWrapped("%s", game::language::MenuNote(int32_t(value)).c_str());
+                ImGui::PopStyleColor();
+                if (env)
+                    ImGui::TextDisabled("%s sets this for this run: %s. The choice here is saved for later runs.", env,
+                        settings::FormatValue(o.id, value).c_str());
+                else if (settings::RestartPending(o.id))
+                {
+                    PushAccentText();
+                    ImGui::TextUnformatted("Takes effect the next time the game starts.");
+                    PopAccentText();
+                }
+                else
+                    ImGui::TextDisabled("Changes take effect the next time the game starts.");
+                return;
+            }
             // The experiment's finer scale wins over Screen Resolution's.
             if (float scale = video::PresentScaleOverride(); o.id == Id::PresentScale && scale > 0.0f)
                 ImGui::TextDisabled("NFSMW_PRESENT_SCALE sets %.2f for this run.", double(scale));
diff --git a/runtime/user/settings.cpp b/runtime/user/settings.cpp
index 6de7595..b2f8e6b 100644
--- a/runtime/user/settings.cpp
+++ b/runtime/user/settings.cpp
@@ -1,6 +1,7 @@
 // SpeedBreaker runtime. GPL-3.0-or-later (see COPYING). See settings.h.
 #include "settings.h"
 #include <user/paths.h>
+#include <game/language.h>  // Settings > Game > Language: the languages
 
 #include <algorithm>
 #include <array>
@@ -13,6 +14,7 @@
 #include <cstdlib>
 #include <cstring>
 #include <format>
+#include <iterator>
 #include <memory>
 #include <mutex>
 #include <optional>
@@ -94,6 +96,22 @@ namespace settings
         // to the screen); elsewhere the window's size is the player's.
         constexpr bool kPresentScaleHidden = !kFullscreenHidden;
 
+        // Settings > Game > Language: game/language.h's table, in its order.
+        constexpr auto kLanguageEntries = [] {
+            std::array<EnumEntry, std::size(game::language::kLanguages)> entries {};
+            for (size_t i = 0; i < entries.size(); i++)
+                entries[i] = { game::language::kLanguages[i].id, game::language::kLanguages[i].token, game::language::kLanguages[i].name };
+            return entries;
+        }();
+        // The game folder can't be reached on iPhone and iPad, and the
+        // installed files decide what a language gives (the note under the
+        // row): the row isn't shown there.
+#if defined(__APPLE__) && TARGET_OS_IOS
+        constexpr bool kLanguageHidden = true;
+#else
+        constexpr bool kLanguageHidden = false;
+#endif
+
         constexpr EnumEntry kAspectEntries[] = {
             { int32_t(AspectMode::Auto), "auto", "Fill Screen" },
             { int32_t(AspectMode::Widescreen), "16:9", "16:9" },
@@ -256,7 +274,7 @@ namespace settings
               .env = "NFSMW_TEXTURE_MIPS", .defaultValue = 1 },
             { .id = Id::InternalResolution, .category = Category::Graphics, .type = Type::Enum, .apply = Apply::Live,
               .table = "video", .key = "internal_resolution", .label = "Internal Resolution",
-              .description = "Render the 3D scene above the 360's 720p. 1.5x is 1080p, a little over half the pixels of 2x. Auto: from the screen (1440p: 2x, or 3x2 filling an ultrawide).",
+              .description = "Render the 3D scene above the 360's 720p. 1.5x is 1080p, a little over half the pixels of 2x. On a screen of another shape filled by Fill Screen, each step renders that shape: 1x on a Steam Deck is its own 1280x800. Auto: from the screen (1440p: 2x; a Steam Deck: its 1280x800).",
               .env = "NFSMW_RESOLUTION", .defaultValue = kResolutionAuto, .entries = kResolutionEntries },
             { .id = Id::WindowWidth, .category = Category::Display, .type = Type::Int, .apply = Apply::Restart, .hidden = true,
               .table = "video", .key = "window_width", .label = "Window Width",
@@ -413,6 +431,11 @@ namespace settings
               .table = "advanced", .key = "performance_overlay", .label = "Performance Overlay",
               .description = "Show the frame rate and frame time in a corner of the screen.",
               .env = "NFSMW_PERF_OVERLAY", .defaultValue = 0 },
+            // Game
+            { .id = Id::GameLanguage, .category = Category::Game, .type = Type::Enum, .apply = Apply::Restart, .hidden = kLanguageHidden,
+              .table = "game", .key = "language", .label = "Language",
+              .description = "The language of the game's menus and race text: English (the USA disc's), or French, German, Italian, Spanish, Dutch, Swedish, Danish, Polish or Finnish, from the same disc's files. The movies and the speech stay in English, as the disc has them.",
+              .env = "NFSMW_LANGUAGE", .defaultValue = double(game::language::kEnglish), .entries = kLanguageEntries },
         };
         static_assert(std::size(kOptions) == kCount, "one row per settings::Id");
 
@@ -504,6 +527,11 @@ namespace settings
             return list;
         }
 
+        // xbox_usb_rumble_note: the "no rumble over USB" note for an Xbox
+        // controller on a Mac (hid/rumble_note.h) was closed.
+        constexpr const char* kRumbleNoteKey = "xbox_usb_rumble_note";
+        std::atomic<bool> s_rumbleNoteShown{ false };
+
         std::vector<int> ParseRates(std::string_view text)
         {
             std::vector<int> out;
@@ -535,9 +563,13 @@ namespace settings
             if (!rates.empty())
                 rates = std::format("# Screen refresh rates (Hz) the refresh-rate notice was closed for: it isn't shown for them again.\n"
                     "{} = \"{}\"\n", kRefreshNoticesKey, rates);
-            if (version.empty() && rates.empty())
+            std::string rumble;
+            if (s_rumbleNoteShown.load(std::memory_order_relaxed))
+                rumble = std::format("# The \"no rumble over USB\" note for an Xbox controller on a Mac was closed: it isn't shown again.\n"
+                    "{} = true\n", kRumbleNoteKey);
+            if (version.empty() && rates.empty() && rumble.empty())
                 return "";
-            return std::format("\n[{}]\n{}{}", kAppTable, version, rates);
+            return std::format("\n[{}]\n{}{}{}", kAppTable, version, rates, rumble);
         }
 
         // `text` (a settings.toml) without its [app] table: from a line that
@@ -1204,6 +1236,7 @@ namespace settings
         case Category::Input: return "Input";
         case Category::Controls: return "Controls";
         case Category::Wheel: return "Wheel";
+        case Category::Game: return "Game";
         case Category::Advanced: return "Advanced";
         default: return "";
         }
@@ -1420,6 +1453,7 @@ namespace settings
         std::array<std::optional<double>, kCount> fileValues;
         std::string text, readError, lastError, lastVersion;
         std::vector<int> notices;
+        bool rumbleNote = false;
         size_t fromFile = 0;
         ReadStatus status = ReadFile(path, text, readError);
         if (status == ReadStatus::Missing)
@@ -1488,6 +1522,15 @@ namespace settings
                                 NodeText(node).c_str());
                         continue;
                     }
+                    if (tableKey.str() == kAppTable && key.str() == kRumbleNoteKey)
+                    {
+                        if (auto v = node.as_boolean())
+                            rumbleNote = v->get();
+                        else
+                            fprintf(stderr, "[settings] %s: %s = %s isn't true or false; ignored\n", path.filename().c_str(), name.c_str(),
+                                NodeText(node).c_str());
+                        continue;
+                    }
                     if (tableKey.str() == kAppTable && key.str() == kLastVersionKey)
                     {
                         if (auto v = node.as_string())
@@ -1532,6 +1575,7 @@ namespace settings
             LastErrorText() = lastError;
             LastVersionText() = lastVersion;
             RefreshNoticesList() = notices;
+            s_rumbleNoteShown.store(rumbleNote, std::memory_order_relaxed);
             s_fileFound = status != ReadStatus::Missing;
             s_fileLoaded = status == ReadStatus::Ok && lastError.empty();
             detail::g_generation.fetch_add(1, std::memory_order_release);
@@ -1700,4 +1744,51 @@ namespace settings
             LoadedPath() = path;
         return true;
     }
+
+    bool RumbleNoteShown()
+    {
+        return s_rumbleNoteShown.load(std::memory_order_relaxed);
+    }
+
+    bool RecordRumbleNote()
+    {
+        std::lock_guard saveLock(s_saveMutex);
+        std::filesystem::path path;
+        std::string lastVersion;
+        std::vector<int> notices;
+        {
+            std::lock_guard lock(s_mutex);
+            if (s_rumbleNoteShown.exchange(true, std::memory_order_relaxed))
+                return true;  // this run doesn't show it again, saved or not
+            if (s_fileFound && !s_fileLoaded)
+            {
+                fprintf(stderr, "[settings] the rumble note isn't recorded: settings.toml didn't load\n");
+                return false;
+            }
+            path = LoadedPath().empty() ? DefaultPath() : LoadedPath();
+            lastVersion = LastVersionText();
+            notices = RefreshNoticesList();
+        }
+        // Only the [app] table changes, as for RecordVersion.
+        std::string text, error;
+        ReadStatus status = ReadFile(path, text, error);
+        if (status == ReadStatus::Failed)
+        {
+            fprintf(stderr, "[settings] the rumble note isn't recorded: can't read %s: %s\n", path.c_str(), error.c_str());
+            return false;
+        }
+        if (status == ReadStatus::Missing)
+            text = "# SpeedBreaker settings. The settings menu writes every option here when one\n"
+                   "# changes; until then each one keeps its default.\n";
+        if (std::string failed = WriteAtomically(path, WithoutAppTable(text) + AppTable(lastVersion, notices)); !failed.empty())
+        {
+            fprintf(stderr, "[settings] the rumble note isn't recorded: %s\n", failed.c_str());
+            return false;
+        }
+        std::lock_guard lock(s_mutex);
+        s_fileFound = s_fileLoaded = true;
+        if (LoadedPath().empty())
+            LoadedPath() = path;
+        return true;
+    }
 }
diff --git a/runtime/user/settings.h b/runtime/user/settings.h
index 93f2786..a866ec0 100644
--- a/runtime/user/settings.h
+++ b/runtime/user/settings.h
@@ -133,6 +133,8 @@ namespace settings
         // Advanced
         AsyncShaders,
         PerformanceOverlay,
+        // Game (the [game] table)
+        GameLanguage,  // game/language.cpp: the game's language, game::language's ids (English = 0)
         Count
     };
     constexpr size_t kCount = size_t(Id::Count);
@@ -140,7 +142,7 @@ namespace settings
     // Key: a key code of user/key_names.h (0: no key), saved by its name
     // there ("w", "left_shift", "none"); the menu takes it from a key press.
     enum class Type : uint8_t { Bool, Int, Float, Enum, Key };
-    enum class Category : uint8_t { Display, Graphics, Audio, Input, Wheel, Controls, Advanced, Count };
+    enum class Category : uint8_t { Display, Graphics, Audio, Input, Wheel, Controls, Game, Advanced, Count };
     enum class Apply : uint8_t { Live, Restart };
 
     // Values of the enum options (GetInt returns them).
@@ -343,4 +345,11 @@ namespace settings
     // the [app] table is rewritten); any thread.
     bool RefreshNoticeShown(int hz);
     bool RecordRefreshNotice(int hz);
+
+    // The "no rumble over USB" note for an Xbox controller on a Mac
+    // (hid/rumble_note.h) was closed: [app] xbox_usb_rumble_note in
+    // settings.toml. Record sets it, in memory and in the file, as
+    // RecordRefreshNotice does; any thread.
+    bool RumbleNoteShown();
+    bool RecordRumbleNote();
 }
diff --git a/runtime/video/picture_fit.cpp b/runtime/video/picture_fit.cpp
index 9fa88da..958df29 100644
--- a/runtime/video/picture_fit.cpp
+++ b/runtime/video/picture_fit.cpp
@@ -98,4 +98,70 @@ namespace video
                 sy--;
         }
     }
+
+    namespace
+    {
+        // A picture narrower than 16:9 (Vert+), wider (Hor+), or 16:9 within
+        // 0.5% (a letterboxed box rounded to whole pixels): AutoRenderScale's
+        // test for its rows.
+        enum class Shape { Wide16x9, Tall, Wide };
+        Shape ShapeOf(uint32_t regionW, uint32_t regionH)
+        {
+            if (!regionW || !regionH)
+                return Shape::Wide16x9;
+            const float aspect = float(regionW) / float(regionH);
+            if (aspect < (16.0f / 9.0f) / 1.005f)
+                return Shape::Tall;
+            if (aspect > (16.0f / 9.0f) * 1.005f)
+                return Shape::Wide;
+            return Shape::Wide16x9;
+        }
+    }
+
+    gpu::RenderScale NativeShape(gpu::AxisScale base, uint32_t regionW, uint32_t regionH)
+    {
+        gpu::RenderScale s{ base, base };
+        switch (ShapeOf(regionW, regionH))
+        {
+        case Shape::Tall:
+        {
+            // The 1280 columns' host ones, and as many rows as the picture
+            // has for them (rounded: 803 for a MacBook's 3024x1898).
+            const uint32_t columns = base.Size(1280);
+            const uint32_t rows = uint32_t(std::lround(double(columns) * double(regionH) / double(regionW)));
+            s.y = gpu::AxisFor(std::max(rows, base.Size(720)), 720);
+            break;
+        }
+        case Shape::Wide:
+        {
+            const uint32_t rows = base.Size(720);
+            const uint32_t columns = uint32_t(std::lround(double(rows) * double(regionW) / double(regionH)));
+            s.x = gpu::AxisFor(std::max(columns, base.Size(1280)), 1280);
+            break;
+        }
+        case Shape::Wide16x9:
+            break;
+        }
+        return s;
+    }
+
+    gpu::RenderScale NativeAuto(uint32_t sx, uint32_t sy, uint32_t regionW, uint32_t regionH, uint32_t budget)
+    {
+        const gpu::RenderScale whole = gpu::RenderScale::Whole(sx, sy);
+        const Shape shape = ShapeOf(regionW, regionH);
+        if (shape == Shape::Wide16x9)
+            return whole;
+        const gpu::RenderScale native = NativeShape({ shape == Shape::Tall ? sx : sy, 1 }, regionW, regionH);
+        // (Exact: num x num / (den x den) against the budget in integers.)
+        if (uint64_t(native.x.num) * native.y.num > uint64_t(budget) * native.x.den * native.y.den)
+            return whole;
+        return native;
+    }
+
+    gpu::RenderScale AutoNativeScale(uint32_t regionW, uint32_t regionH, uint32_t budget)
+    {
+        uint32_t sx = 1, sy = 1;
+        AutoRenderScale(regionW, regionH, budget, sx, sy);
+        return NativeAuto(sx, sy, regionW, regionH, budget);
+    }
 }
diff --git a/runtime/video/picture_fit.h b/runtime/video/picture_fit.h
index c8aafeb..4416e75 100644
--- a/runtime/video/picture_fit.h
+++ b/runtime/video/picture_fit.h
@@ -17,6 +17,8 @@
 // Otherwise (16:9 within those margins, the 16:9 setting, or a ppc/ without
 // the hooks) the 16:9 frame is letterboxed as it always was.
 #pragma once
+#include <gpu/render_scale.h>
+
 #include <cstdint>
 
 namespace video
@@ -28,8 +30,8 @@ namespace video
     // the same 1% margin as Hor+: 16:10 (1.11: the Steam Deck's 1280x800,
     // 16:10 Macs), 3:2 (1.19) and a 4:3 iPad (1.33) fill. 16:9 itself, and
     // a screen within 1% of it (1360x768), keeps the letterboxed 16:9 frame.
-    // On the Deck, AutoRenderScale keeps 1x1, so the frame's 720 rows are
-    // stretched to 800 (1.11) rather than drawn 1:1 in a 720-row box.
+    // The frame's 720 rows used to be stretched to the Deck's 800 (1.11) at
+    // 1x; now they are rendered as 800 host rows (NativeShape, GitHub #34).
     constexpr float kTallMinStretch = 1.01f;
 
     struct PictureFit
@@ -70,4 +72,24 @@ namespace video
     // screen (video::FrameRegion), within `budget` host pixels per guest
     // pixel.
     void AutoRenderScale(uint32_t regionW, uint32_t regionH, uint32_t budget, uint32_t& sx, uint32_t& sy);
+
+    // Native rows and columns (GitHub #34): a picture covering regionW x
+    // regionH narrower than 16:9 (Vert+) keeps `base` across and gets the
+    // rows its shape asks at that many columns; a wider one (Hor+) keeps
+    // `base` down and gets the columns. So 1x on a Steam Deck's 1280x800
+    // renders 1280x800 (1x10/9), the presenter showing it 1:1, not the 720
+    // rows of a 16:9 frame stretched to 800; 1.5x on 1920x1200 renders
+    // 1920x1200 and 2x on a 3440x1440 ultrawide 3440x1440. A picture within
+    // 0.5% of 16:9 (a letterboxed 16:9 box, as AutoRenderScale tells it)
+    // keeps `base` both ways, exactly as before. No region: `base` too.
+    gpu::RenderScale NativeShape(gpu::AxisScale base, uint32_t regionW, uint32_t regionH);
+
+    // Auto with native rows and columns: Auto's whole scale sx x sy
+    // (AutoRenderScale's), unless the picture is Vert+ or Hor+ and NativeShape
+    // at its scale across (Vert+) or down (Hor+) fits the budget too (the
+    // Deck's 1x10/9 within 4; 3440x1440's 2.6875x2 within 6, in place of
+    // 3x2): then that.
+    gpu::RenderScale NativeAuto(uint32_t sx, uint32_t sy, uint32_t regionW, uint32_t regionH, uint32_t budget);
+    // AutoRenderScale's scale through NativeAuto.
+    gpu::RenderScale AutoNativeScale(uint32_t regionW, uint32_t regionH, uint32_t budget);
 }
diff --git a/runtime/video/presenter.cpp b/runtime/video/presenter.cpp
index c2c06ff..9fff7ef 100644
--- a/runtime/video/presenter.cpp
+++ b/runtime/video/presenter.cpp
@@ -13,6 +13,7 @@
 #include <game/cover_callers.h>
 #include <gpu/covers.h>
 #include "gpu_choice.h"
+#include <gpu/pcie_link.h>
 #include "present_schedule.h"
 #include "hfr_schedule.h"
 #include <game/hfr.h>
@@ -2631,8 +2632,10 @@ void main()
         std::vector<VkExtensionProperties> avail(extAvail);
         vkEnumerateDeviceExtensionProperties(s_physical, nullptr, &extAvail, avail.data());
         bool presentId = false, presentWait = false, hostImport = false, shadingRate = false, displayTiming = false;
+        bool pciBusInfo = false;  // (a property query only: not enabled)
         for (auto& e : avail)
         {
+            pciBusInfo |= strcmp(e.extensionName, VK_EXT_PCI_BUS_INFO_EXTENSION_NAME) == 0;
             displayTiming |= strcmp(e.extensionName, VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME) == 0;
             if (strcmp(e.extensionName, "VK_KHR_portability_subset") == 0)
                 devExts.push_back("VK_KHR_portability_subset");
@@ -2889,12 +2892,29 @@ void main()
                     vkGetPhysicalDeviceProperties2(s_physical, &props2);
                     driver = std::format("{} {}", driverProps.driverName, driverProps.driverInfo);
                 }
+                // Issue #40: a discrete GPU's PCIe link (Linux: sysfs), which
+                // bounds it when guest memory is in system memory (gpu/pcie_link.h).
+                std::string link;
+#if defined(__linux__) && !defined(__ANDROID__)
+                if (pciBusInfo && props.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU && props.apiVersion >= VK_API_VERSION_1_1)
+                {
+                    VkPhysicalDevicePCIBusInfoPropertiesEXT pci{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT };
+                    VkPhysicalDeviceProperties2 props2{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 };
+                    props2.pNext = &pci;
+                    vkGetPhysicalDeviceProperties2(s_physical, &props2);
+                    link = gpu::pcie::Describe(gpu::pcie::Read(gpu::pcie::SysfsDir(pci.pciDomain, pci.pciBus, pci.pciDevice, pci.pciFunction)));
+                    if (!link.empty())
+                        fprintf(stderr, "[video] PCIe link: %s\n", link.c_str());
+                }
+#else
+                (void)pciBusInfo;
+#endif
                 uint32_t loader = VK_API_VERSION_1_0;
                 vkEnumerateInstanceVersion(&loader);
-                report::SetSystemItem("GPU", std::format("{} ({}, {:04x}:{:04x}), {}, Vulkan {}.{}.{} (loader {}.{}.{})",
+                report::SetSystemItem("GPU", std::format("{} ({}, {:04x}:{:04x}), {}, Vulkan {}.{}.{} (loader {}.{}.{}){}",
                     props.deviceName, type, props.vendorID, props.deviceID, driver, VK_API_VERSION_MAJOR(props.apiVersion),
                     VK_API_VERSION_MINOR(props.apiVersion), VK_API_VERSION_PATCH(props.apiVersion), VK_API_VERSION_MAJOR(loader),
-                    VK_API_VERSION_MINOR(loader), VK_API_VERSION_PATCH(loader)));
+                    VK_API_VERSION_MINOR(loader), VK_API_VERSION_PATCH(loader), link.empty() ? std::string() : ", " + link));
                 UpdateDisplayItem();
             }
             if (s_gameMode && mode && nativeW > 0 && int64_t(mode->w) * mode->h < int64_t(nativeW) * nativeH)
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index e3e3157..6393355 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -18,6 +18,8 @@ endfunction()
 sb_test(block_ranges_test)
 # Where guest memory and the upload ring go (gpu/memory_plan.h, header only).
 sb_test(memory_plan_test)
+# A discrete GPU's PCIe link for the logs (gpu/pcie_link.h, header only; issue #40).
+sb_test(pcie_link_test)
 sb_test(zpd_report_test)
 # The resolve shader's 24-bit depth pack (gpu/depth24_glsl.h), header only;
 # renderer.cpp is read to check its resolve shader uses it.
@@ -60,6 +62,10 @@ sb_test(covers_test)
 # line that says so (gpu/pipeline_cache_header.h, header only).
 sb_test(pipeline_cache_header_test)
 sb_test(picture_fit_test SOURCES ${RT}/video/picture_fit.cpp)
+# GitHub #34's native rows and columns (video::NativeShape, AutoNativeScale):
+# a Steam Deck's 1280x800 at 1x renders 1280x800, 16:9 pictures keep their
+# scale exactly, Auto takes the native shape within its budget.
+sb_test(native_rows_test SOURCES ${RT}/video/picture_fit.cpp)
 # Which Vulkan device the presenter draws with, and its log line
 # (video/gpu_choice.h, header only).
 sb_test(gpu_choice_test)
@@ -113,6 +119,12 @@ sb_test(refresh_fit_test SOURCES ${RT}/video/refresh_fit.cpp)
 # user/settings.cpp).
 sb_test(refresh_notice_test SOURCES ${RT}/video/refresh_fit.cpp ${RT}/user/settings.cpp
     ARGS ${CMAKE_CURRENT_BINARY_DIR}/refresh_notice_scratch)
+# The one-time note that an Xbox controller by USB on a Mac takes no rumble
+# (hid/rumble_note.h): a wired Xbox pad on a Mac gets it once, a DualSense
+# wired, an Xbox pad over Bluetooth and other platforms never; the dismissal
+# in settings.toml, in a scratch folder (user/settings.cpp).
+sb_test(rumble_note_test SOURCES ${RT}/user/settings.cpp
+    ARGS ${CMAKE_CURRENT_BINARY_DIR}/rumble_note_scratch)
 # How late the guest vblank's thread wakes on this machine, alone and with
 # every core busy (video/vblank_timer.cpp; checked on macOS, where its
 # scheduling changed in v0.1.4).
@@ -230,6 +242,11 @@ set_target_properties(key_names_test PROPERTIES SKIP_BUILD_RPATH OFF)
 # vendors; no SDL).
 sb_test(settings_keys_test SOURCES ${RT}/user/settings.cpp)
 target_include_directories(settings_keys_test SYSTEM PRIVATE ${ROOT}/tools/XenonRecomp/thirdparty/tomlplusplus/include)
+# Settings > Game > Language (game/language.h, header only, and the option in
+# user/settings.cpp): English untouched for every caller, the game's ten
+# languages, the movie suffix by the files present, what the files give.
+sb_test(language_test SOURCES ${RT}/user/settings.cpp)
+target_include_directories(language_test SYSTEM PRIVATE ${ROOT}/tools/XenonRecomp/thirdparty/tomlplusplus/include)
 # The keyboard's controls and how held keys become a pad (hid/key_map.h), header only.
 sb_test(key_map_test)
 # A USB steering wheel as the pad (hid/wheel_map.h, header only): which
diff --git a/tests/language_test.cpp b/tests/language_test.cpp
new file mode 100644
index 0000000..9e1eaaa
--- /dev/null
+++ b/tests/language_test.cpp
@@ -0,0 +1,367 @@
+// Tests for Settings > Game > Language (runtime/game/language.h, and the
+// option in user/settings.cpp): the boot's language, the movie suffix and the
+// speech record game/language.cpp hooks, the game's table, what the installed files give a
+// language, and the option itself. Links user/settings.cpp (and toml++ from
+// XenonRecomp's vendored copy); no game files. From the repo root:
+//   clang++ -std=c++20 -O2 -Iruntime -Itools/XenonRecomp/thirdparty/tomlplusplus/include \
+//     tests/language_test.cpp runtime/user/settings.cpp -o build/language_test && build/language_test
+#include <game/language.h>
+#include <user/settings.h>
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <filesystem>
+#include <fstream>
+#include <iterator>
+#include <set>
+#include <sstream>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include <unistd.h>  // mkdtemp
+#ifdef __APPLE__
+#include <TargetConditionals.h>  // TARGET_OS_IOS: the row is hidden there
+#endif
+
+static int g_failures = 0;
+#define CHECK(cond, ...) do { if (!(cond)) { g_failures++; printf("  FAIL %s:%d: %s: ", __FILE__, __LINE__, #cond); printf(__VA_ARGS__); printf("\n"); } } while (0)
+
+using namespace game::language;
+
+namespace
+{
+    // The game's language table (0x828FF000 in the USA default.xex, 10
+    // records of 20 bytes: index, name, LANGUAGES\<NAME>.BIN, ...), copied
+    // from the image in its order.
+    struct GameEntry { int32_t index; const char* name; };
+    constexpr GameEntry kGameTable[] = {
+        { 0, "ENGLISH" }, { 1, "FRENCH" }, { 2, "GERMAN" }, { 3, "ITALIAN" }, { 4, "SPANISH" },
+        { 5, "DUTCH" }, { 6, "SWEDISH" }, { 12, "POLISH" }, { 13, "FINNISH" }, { 7, "DANISH" },
+    };
+
+    // Callers of SetCurrentLanguage (the boot, the debug cycling's, the
+    // unused English tail call's) and of the movie sprintf (the movie name,
+    // two of the other 145), plus nonsense.
+    constexpr uint32_t kCallers[] = { kBootCall, 0x822BC738, 0x822BCD08, kMovieNameCall, 0x82282A5C, 0x8230F1C4, 0, 0xFFFFFFFF };
+
+    void PutHash(std::vector<uint8_t>& zdir, uint32_t h)
+    {
+        uint8_t e[24] = {};
+        e[0] = uint8_t(h);
+        e[1] = uint8_t(h >> 8);
+        e[2] = uint8_t(h >> 16);
+        e[3] = uint8_t(h >> 24);
+        zdir.insert(zdir.end(), e, e + 24);
+    }
+
+    // An archive index as the USA disc's: every language's text, English's
+    // police radio only.
+    std::vector<uint8_t> UsaIndex()
+    {
+        std::vector<uint8_t> zdir;
+        PutHash(zdir, ArchiveHash("SOUND\\SPEECH\\COPSPEECH_EN.BIG"));
+        for (const Language& l : kLanguages)
+            PutHash(zdir, ArchiveHash(std::string("LANGUAGES\\") + l.disc + ".BIN"));
+        PutHash(zdir, 0x12345678);
+        return zdir;
+    }
+
+    // The USA disc's Movies/ (33 files, all <name>_english_ntsc.wmv).
+    std::vector<std::string> UsaMovies()
+    {
+        std::vector<std::string> m;
+        for (const char* n : { "attract_movie", "bounty_tutorial", "drag_tutorial", "eahd_bumper", "ealogo", "psa", "pursuit_tutorial",
+                 "speedtrap_tutorial", "storyfmv_bla134", "storyfmv_bus12", "storyfmv_cro06_coh06a", "storyfmv_her136", "storyfmv_pin11",
+                 "storyfmv_rac01", "storyfmv_rap30", "storyfmv_raz08", "storyfmv_saf25", "tollbooth_tutorial" })
+            m.push_back(std::string(n) + "_english_ntsc.wmv");
+        for (int i = 1; i <= 15; i++)
+        {
+            char n[64];
+            snprintf(n, sizeof(n), "blacklist_%02d_english_ntsc.wmv", i);
+            m.push_back(n);
+        }
+        return m;
+    }
+
+    const Language& L(int32_t id)
+    {
+        return *Find(id);
+    }
+
+    std::string ReadAll(const std::filesystem::path& file)
+    {
+        std::ifstream f(file);
+        std::stringstream s;
+        s << f.rdbuf();
+        return s.str();
+    }
+
+    void TestTable()
+    {
+        CHECK(std::size(kLanguages) == 10, "ten languages, %zu", std::size(kLanguages));
+        CHECK(kLanguages[0].id == kEnglish && std::string_view(kLanguages[0].token) == "english", "English first (the fallback's)");
+        std::set<int32_t> ids;
+        for (const GameEntry& g : kGameTable)
+        {
+            const Language* l = Find(g.index);
+            CHECK(l != nullptr, "the game's %d (%s) is offered", g.index, g.name);
+            if (!l)
+                continue;
+            CHECK(std::string_view(l->disc) == g.name, "%d: %s, the game's %s", g.index, l->disc, g.name);
+            std::string token = g.name, name = g.name, speech;
+            for (char& c : token)
+                c = char(std::tolower(uint8_t(c)));
+            for (size_t i = 1; i < name.size(); i++)
+                name[i] = char(std::tolower(uint8_t(name[i])));
+            // The game's speech switch (sub_821B82E8): own banks for 1-4.
+            speech = g.index >= 1 && g.index <= 4 ? token.substr(0, 2) : "en";
+            CHECK(token == l->token, "%d: token %s", g.index, l->token);
+            CHECK(name == l->name, "%d: name %s", g.index, l->name);
+            CHECK(speech == l->speech, "%d: speech code %s", g.index, l->speech);
+            ids.insert(l->id);
+        }
+        CHECK(ids == std::set<int32_t>({ 0, 1, 2, 3, 4, 5, 6, 7, 12, 13 }), "the ten values 0-7, 12, 13");
+        for (int32_t id : { -1, 8, 9, 10, 11, 14, 100 })
+            CHECK(Find(id) == nullptr, "%d is not a language", id);
+    }
+
+    void TestBoot()
+    {
+        // English, the default: the executable's r3 for every caller.
+        for (uint32_t lr : kCallers)
+            for (int32_t r3 : { 0, 1, 4, 13, -1 })
+                CHECK(BootLanguage(lr, r3, kEnglish) == r3, "English leaves lr %08X r3 %d alone", lr, r3);
+        // Another language: only the boot's call changes.
+        for (const Language& l : kLanguages)
+            for (uint32_t lr : kCallers)
+                for (int32_t r3 : { 0, 4 })
+                {
+                    const int32_t want = lr == kBootCall && l.id != kEnglish ? l.id : r3;
+                    CHECK(BootLanguage(lr, r3, l.id) == want, "%s at lr %08X r3 %d: %d", l.token, lr, r3, BootLanguage(lr, r3, l.id));
+                }
+    }
+
+    void TestMovieSuffix()
+    {
+        constexpr uint32_t kOther = 0x82078AC4;  // another string the sprintf gets in r9
+        for (uint32_t lr : kCallers)
+            for (uint32_t r9 : { kNtscSuffix, kPalSuffix, kOther, 0u })
+            {
+                CHECK(MovieSuffix(lr, r9, false) == r9, "no PAL movies: lr %08X r9 %08X unchanged", lr, r9);
+                const uint32_t want = lr == kMovieNameCall && r9 == kNtscSuffix ? kPalSuffix : r9;
+                CHECK(MovieSuffix(lr, r9, true) == want, "PAL movies: lr %08X r9 %08X -> %08X", lr, r9, MovieSuffix(lr, r9, true));
+            }
+    }
+
+    void TestSpeechIndex()
+    {
+        // sub_821B82E8's returns from its lookups (one per case, English's
+        // last), callers elsewhere, and the edges of its range.
+        const uint32_t lrs[] = { 0x821B83C8, 0x821B8428, 0x821B8488, 0x821B84E8, 0x821B8548, 0x821B85E4, kSpeechPickBegin,
+            kSpeechPickEnd - 4, kSpeechPickEnd, kSpeechPickBegin - 4, 0x821BD4D0, 0x8248B2A8, kBootCall, 0 };
+        for (uint32_t lr : lrs)
+            for (uint32_t r4 : { kSpeechCollection, 0x4166FA80u, 0u })
+                for (uint32_t r5 : { 0u, 1u, 2u, 3u, 4u, 5u })
+                {
+                    CHECK(SpeechIndex(lr, r4, r5, false) == r5, "no fallback: lr %08X r4 %08X r5 %u unchanged", lr, r4, r5);
+                    const bool inside = lr >= kSpeechPickBegin && lr < kSpeechPickEnd && r4 == kSpeechCollection;
+                    CHECK(SpeechIndex(lr, r4, r5, true) == (inside ? kEnglishSpeech : r5), "fallback: lr %08X r4 %08X r5 %u", lr, r4, r5);
+                }
+    }
+
+    void TestArchiveHash()
+    {
+        // Keys in the USA disc's NFS/ZDIR.BIN, for paths as the game asks.
+        CHECK(ArchiveHash("D:\\Sound\\Speech\\copspeech_en.big") == 0xF9F10F64, "%08X", ArchiveHash("D:\\Sound\\Speech\\copspeech_en.big"));
+        CHECK(ArchiveHash("D:\\Sound\\Speech\\copspeech_en.idx") == 0xF9F12C97, "%08X", ArchiveHash("D:\\Sound\\Speech\\copspeech_en.idx"));
+        CHECK(ArchiveHash("LANGUAGES\\SPANISH.BIN") == 0x983729EF, "%08X", ArchiveHash("LANGUAGES\\SPANISH.BIN"));
+        CHECK(ArchiveHash("D:\\LANGUAGES\\ENGLISH.BIN") == 0x27771A63, "%08X", ArchiveHash("D:\\LANGUAGES\\ENGLISH.BIN"));
+        CHECK(ArchiveHash("sound/streams/nisaudio.big") == 0x059CAA5B, "%08X", ArchiveHash("sound/streams/nisaudio.big"));
+        std::vector<uint8_t> zdir = UsaIndex();
+        CHECK(InArchive(zdir, "D:\\Sound\\Speech\\CopSpeech_EN.big"), "any case");
+        CHECK(!InArchive(zdir, "D:\\Sound\\Speech\\copspeech_sp.big"), "no Spanish bank");
+        std::vector<uint8_t> cut;
+        PutHash(cut, ArchiveHash("LANGUAGES\\POLISH.BIN"));
+        cut.resize(23);
+        CHECK(!InArchive(cut, "LANGUAGES\\POLISH.BIN"), "a cut-off entry is not read");
+        CHECK(!InArchive({}, "LANGUAGES\\ENGLISH.BIN"), "no index: nothing");
+    }
+
+    void TestFiles()
+    {
+        const std::vector<uint8_t> usa = UsaIndex();
+        const std::vector<std::string> usaMovies = UsaMovies();
+        CHECK(usaMovies.size() == 33, "the USA disc's 33 movies");
+
+        // The USA disc's files: English is the disc's own, all of it.
+        Files en = Scan(L(kEnglish), usaMovies, usa);
+        CHECK(en.text && !en.pal && en.ownMovies && en.speech && !en.speechToEnglish, "English on the USA disc");
+        CHECK(Note(L(kEnglish), en) == "Menus, race text, movies and speech in English.", "%s", Note(L(kEnglish), en).c_str());
+        CHECK(LogLine(L(kEnglish), en) == "[language] English (english): text yes; movies English (_ntsc); speech English (copspeech_en present)",
+            "%s", LogLine(L(kEnglish), en).c_str());
+        // ...and every other language: its text, the English movies (_ntsc
+        // kept), English speech: the game's own for five of them, the
+        // fallback for French, German, Italian and Spanish.
+        for (const Language& l : kLanguages)
+        {
+            if (l.id == kEnglish)
+                continue;
+            Files f = Scan(l, usaMovies, usa);
+            const bool own = std::string_view(l.speech) != "en";
+            CHECK(f.text && !f.pal && !f.ownMovies && f.englishMovies && f.englishSpeech, "%s on the USA disc", l.token);
+            CHECK(f.speech == !own && f.speechToEnglish == own, "%s: speech %d, to English %d", l.token, f.speech, f.speechToEnglish);
+            CHECK(MoviesIn(l, f) == "English" && SpeechIn(l, f) == "English", "%s: movies and speech in English", l.token);
+            CHECK(MovieSuffix(kMovieNameCall, kNtscSuffix, f.pal) == kNtscSuffix, "%s keeps _ntsc", l.token);
+            CHECK(Note(l, f) == std::string("Menus and race text in ") + l.name + ". Movies and speech in English.", "%s", Note(l, f).c_str());
+        }
+        Files es = Scan(L(4), usaMovies, usa);
+        CHECK(LogLine(L(4), es) == "[language] Spanish (spanish): text yes; movies English (_ntsc); speech English (copspeech_sp absent: English's instead)",
+            "%s", LogLine(L(4), es).c_str());
+        Files nl = Scan(L(5), usaMovies, usa);
+        CHECK(LogLine(L(5), nl) == "[language] Dutch (dutch): text yes; movies English (_ntsc); speech English (copspeech_en present)",
+            "%s", LogLine(L(5), nl).c_str());
+        // English never falls back (its lookups stay the game's), whatever
+        // the files.
+        for (const auto& movies : { usaMovies, std::vector<std::string> {} })
+            for (const auto& index : { usa, std::vector<uint8_t> {} })
+                CHECK(!Scan(L(kEnglish), movies, index).speechToEnglish, "English: no fallback");
+        // No English bank either: nothing to fall back to.
+        std::vector<uint8_t> noSpeech;
+        PutHash(noSpeech, ArchiveHash("LANGUAGES\\SPANISH.BIN"));
+        Files mute = Scan(L(4), usaMovies, noSpeech);
+        CHECK(!mute.speech && !mute.speechToEnglish && SpeechIn(L(4), mute).empty(), "no bank at all");
+        CHECK(Note(L(4), mute) == "Menus and race text in Spanish. Movies in English. No speech (the installed files have none for it).",
+            "%s", Note(L(4), mute).c_str());
+
+        // A language's PAL movies, alone (any case): _pal, its own movies.
+        std::vector<std::string> pal = { "ealogo_spanish_pal.wmv", "ATTRACT_MOVIE_SPANISH_PAL.WMV", "Psa_Spanish_Pal.Wmv" };
+        Files esPal = Scan(L(4), pal, usa);
+        CHECK(esPal.pal && esPal.ownMovies && !esPal.englishMovies, "Spanish PAL movies");
+        CHECK(MoviesIn(L(4), esPal) == "Spanish", "in Spanish");
+        CHECK(MovieSuffix(kMovieNameCall, kNtscSuffix, esPal.pal) == kPalSuffix, "-> _pal");
+        Files dePal = Scan(L(2), pal, usa);
+        CHECK(!dePal.pal && !dePal.ownMovies && !dePal.englishMovies, "German with only Spanish movies: _ntsc, no movies");
+        CHECK(Note(L(2), dePal).find("No movies") != std::string::npos, "%s", Note(L(2), dePal).c_str());
+
+        // Both (the USA disc reinstalled over PAL movies): the language that
+        // has PAL movies takes them; English keeps the USA disc's.
+        std::vector<std::string> both = usaMovies;
+        both.insert(both.end(), pal.begin(), pal.end());
+        CHECK(Scan(L(4), both, usa).pal, "Spanish PAL movies beside the USA disc's: _pal");
+        CHECK(!Scan(L(kEnglish), both, usa).pal, "English: the USA disc's _ntsc");
+        CHECK(!Scan(L(1), both, usa).pal && Scan(L(1), both, usa).englishMovies, "French: _ntsc, English movies");
+        // English PAL movies only (a European English disc's): _pal for English.
+        std::vector<std::string> ukPal = { "ealogo_english_pal.wmv" };
+        CHECK(Scan(L(kEnglish), ukPal, usa).pal && Scan(L(kEnglish), ukPal, usa).ownMovies, "English PAL movies alone: _pal");
+        CHECK(Scan(L(1), ukPal, usa).pal == false && Scan(L(1), ukPal, usa).englishMovies == false, "French: _ntsc, the fallback has none");
+        // ...but beside the USA disc's own English movies, English keeps them.
+        std::vector<std::string> enBoth = usaMovies;
+        enBoth.push_back("ealogo_english_pal.wmv");
+        CHECK(!Scan(L(kEnglish), enBoth, usa).pal, "English NTSC and PAL movies: the USA disc's _ntsc");
+        // Names that only look like it.
+        std::vector<std::string> odd = { "_spanish_pal.wmv", "ealogo_spanish_pal.wmv.part", "ealogo_spanish_pal.bik", "ealogo_xspanish_pal.wmv" };
+        CHECK(!Scan(L(4), odd, usa).pal, "no real Spanish PAL movie there");
+
+        // A language's speech bank in the index: its police radio.
+        std::vector<uint8_t> withEs = usa;
+        PutHash(withEs, ArchiveHash("SOUND\\SPEECH\\COPSPEECH_SP.BIG"));
+        Files esAll = Scan(L(4), pal, withEs);
+        CHECK(esAll.speech && !esAll.speechToEnglish, "Spanish speech, no fallback");
+        CHECK(Note(L(4), esAll) == "Menus, race text, movies and speech in Spanish.", "%s", Note(L(4), esAll).c_str());
+        // Nothing found (an unreadable folder): said, not guessed.
+        Files none = Scan(L(4), {}, {});
+        CHECK(!none.text && !none.pal && !none.ownMovies && !none.englishMovies && !none.speech, "no files");
+        CHECK(Note(L(4), none) == "The installed files have no Spanish text. No movies (the installed files have none for it). No speech (the installed files have none for it).",
+            "%s", Note(L(4), none).c_str());
+    }
+
+    void TestOption(const std::filesystem::path& dir)
+    {
+        using namespace settings;
+        const Option& o = Info(Id::GameLanguage);
+        CHECK(std::string_view(o.table) == "game" && std::string_view(o.key) == "language", "[game] language");
+        CHECK(std::string_view(o.label) == "Language", "label %s", o.label);
+        CHECK(o.category == Category::Game && std::string_view(CategoryName(o.category)) == "Game", "Settings > Game");
+        CHECK(o.type == Type::Enum && o.apply == Apply::Restart, "an enum, at the next launch");
+        CHECK(std::string_view(o.env) == "NFSMW_LANGUAGE", "env %s", o.env);
+        CHECK(o.defaultValue == double(kEnglish), "English by default");
+#if defined(__APPLE__) && TARGET_OS_IOS
+        CHECK(o.hidden, "not shown on iPhone and iPad");
+#else
+        CHECK(!o.hidden, "shown");
+#endif
+        CHECK(std::string_view(o.description).find("next launch") == std::string_view::npos, "said once, by the file's env note");
+        CHECK(std::string_view(o.description).find("PAL") == std::string_view::npos, "no PAL in the description");
+        CHECK(o.entries.size() == std::size(kLanguages), "%zu entries", o.entries.size());
+        for (size_t i = 0; i < o.entries.size() && i < std::size(kLanguages); i++)
+        {
+            CHECK(o.entries[i].value == kLanguages[i].id, "entry %zu value", i);
+            CHECK(std::string_view(o.entries[i].token) == kLanguages[i].token, "entry %zu token", i);
+            CHECK(std::string_view(o.entries[i].label) == kLanguages[i].name, "entry %zu: \"%s\"", i, o.entries[i].label);
+        }
+
+        // The file: a name in any case. The first Load fixes this run's
+        // language (a Restart option), as at launch.
+        const std::filesystem::path file = dir / "settings.toml";
+        std::ofstream(file) << "[game]\nlanguage = \"SPANISH\"\n";
+        CHECK(Load(file), "load");
+        CHECK(GetInt(Id::GameLanguage) == 4 && GetStoredValue(Id::GameLanguage) == 4, "\"SPANISH\": Spanish, running %d",
+            GetInt(Id::GameLanguage));
+        CHECK(FormatValue(Id::GameLanguage, 4) == "Spanish", "%s", FormatValue(Id::GameLanguage, 4).c_str());
+        // The menu: German waits for the next launch, and is what's saved.
+        CHECK(Set(Id::GameLanguage, 2) == SetResult::Deferred, "deferred");
+        CHECK(GetInt(Id::GameLanguage) == 4 && GetStoredValue(Id::GameLanguage) == 2 && RestartPending(Id::GameLanguage),
+            "this run stays Spanish, German saved");
+        CHECK(Save(file), "save");
+        const std::string text = ReadAll(file);
+        CHECK(text.find("[game]") != std::string::npos && text.find("language = \"german\"") != std::string::npos, "%s", text.c_str());
+        CHECK(text.find("(NFSMW_LANGUAGE; applies at the next launch)") != std::string::npos, "the env note");
+        const size_t row = text.find("# Language:"), value = text.find("language =", row);
+        const std::string block = row == std::string::npos || value == std::string::npos ? "" : text.substr(row, value - row);
+        size_t times = 0;
+        for (size_t at = block.find("next launch"); at != std::string::npos; at = block.find("next launch", at + 1))
+            times++;
+        CHECK(times == 1, "the Language row says \"next launch\" once, not %zu times:\n%s", times, block.c_str());
+        // Not a language: numbers and unknown words are refused.
+        CHECK(Set(Id::GameLanguage, 8) == SetResult::Invalid, "8 is no language");
+        CHECK(Set(Id::GameLanguage, 12) != SetResult::Invalid, "12 (Polish) is");
+        for (const char* bad : { "4", "\"4\"", "\"klingon\"", "\"pal\"" })
+        {
+            std::ofstream(file) << "[game]\nlanguage = " << bad << "\n";
+            Load(file);
+            const double stored = GetStoredValue(Id::GameLanguage);
+            CHECK(stored == double(kEnglish), "%s: refused, the default stored (%g)", bad, stored);
+            CHECK(GetInt(Id::GameLanguage) == 4, "%s: this run keeps Spanish", bad);
+        }
+    }
+}
+
+int main()
+{
+    TestTable();
+    TestBoot();
+    TestMovieSuffix();
+    TestSpeechIndex();
+    TestArchiveHash();
+    TestFiles();
+
+    char tmpl[] = "/tmp/language_test.XXXXXX";
+    const char* dir = mkdtemp(tmpl);
+    CHECK(dir != nullptr, "a scratch folder");
+    if (dir)
+    {
+        unsetenv("NFSMW_LANGUAGE");
+        TestOption(dir);
+        std::filesystem::remove_all(dir);
+    }
+
+    if (g_failures)
+    {
+        printf("language_test: %d failure(s)\n", g_failures);
+        return 1;
+    }
+    printf("language_test: all passed\n");
+    return 0;
+}
diff --git a/tests/memory_plan_test.cpp b/tests/memory_plan_test.cpp
index 05e0972..35059ad 100644
--- a/tests/memory_plan_test.cpp
+++ b/tests/memory_plan_test.cpp
@@ -309,10 +309,38 @@ static void Types()
         Size(256 * MB).c_str(), Size(8573157376ull).c_str(), Size(16621477888ull).c_str());
 }
 
+// Issue #40: an RTX 5060 Ti on NVIDIA 615.78.08 (Linux), a 246 MB BAR window
+// (its log: "0 16 GB device-local, 1 12 GB, 2 246 MB device-local; types
+// 0:1/0 1:0/1 2:1/6 3:1/E 4:2/7"). Both in system memory, as its log says,
+// and the log now says the GPU reads them over PCIe.
+static void OverPcie()
+{
+    printf("over PCIe (issue #40):\n");
+    Memory m{ { { 0x0, 1 }, { 0x1, 0 }, { 0x6, 1 }, { 0xE, 1 }, { 0x7, 2 } }, { 16 * GB, 12 * GB, 246 * MB } };
+    Plan g = PlanGuestMemory(m, Input(Gpu::kDiscrete, true, 4));
+    Expect("RTX 5060 Ti 246 MB BAR, guest memory", g, false, "import,copy-system:2,copy-cached:3,copy-vram:4!", "no resizable BAR");
+    Expect("RTX 5060 Ti 246 MB BAR, ring (imported)", PlanRing(m, ~0u, kNoType), true, "ring-cached:3,ring-system:2,ring-vram:4!");
+    // Imported guest memory and a cached ring: both named.
+    const char* both = OverPcieNote(Gpu::kDiscrete, false, false);
+    CHECK(both && std::string(both).find("upload ring") != std::string::npos && std::string(both).find("Resizable BAR") != std::string::npos,
+        "both over PCIe: %s", both ? both : "(none)");
+    // NFSMW_RING_MEMORY=vram (the ring in the BAR window): guest memory only.
+    const char* guest = OverPcieNote(Gpu::kDiscrete, false, true);
+    CHECK(guest && std::string(guest).find("upload ring") == std::string::npos, "guest over PCIe: %s", guest ? guest : "(none)");
+    // With resizable BAR the copy is in VRAM: nothing to say.
+    CHECK(!OverPcieNote(Gpu::kDiscrete, true, true), "resizable BAR noted");
+    CHECK(!OverPcieNote(Gpu::kDiscrete, true, false), "copy in VRAM, ring cached noted");
+    // Integrated GPUs and unified memory (the Deck, the Frame, Apple) read
+    // system memory as their own.
+    CHECK(!OverPcieNote(Gpu::kIntegrated, false, false), "integrated noted");
+    CHECK(!OverPcieNote(Gpu::kOther, false, false), "other noted");
+}
+
 int main()
 {
     Unchanged();
     NoRebar();
+    OverPcie();
     Intel();
     EnvOverrides();
     TestHook();
diff --git a/tests/native_rows_test.cpp b/tests/native_rows_test.cpp
new file mode 100644
index 0000000..dcdae62
--- /dev/null
+++ b/tests/native_rows_test.cpp
@@ -0,0 +1,190 @@
+// Tests for native rows and columns (GitHub #34): video::NativeShape and
+// video::AutoNativeScale (runtime/video/picture_fit.cpp). From the repo root:
+//   clang++ -std=c++20 -O2 -Iruntime tests/native_rows_test.cpp runtime/video/picture_fit.cpp -o build/native_rows_test
+//   build/native_rows_test
+// The report: on a Steam Deck (1280x800, Fill Screen, Internal Resolution
+// 1x) the game rendered its 16:9 frame's 720 rows and the presenter
+// stretched them to 800, so the picture was softer than at 16:9, whose 720
+// rows it showed 1:1. Checked:
+//   - a Vert+ picture renders the rows its shape has at the setting's
+//     columns, a Hor+ one the columns at its rows: the Deck's 1280x800 at 1x
+//     is 1280x800, shown 1:1; 1.5x on 1920x1200 and 2x on 2560x1600 too; a
+//     MacBook's 3024x1898 within a pixel of its shape; ultrawides, 4:3, a
+//     phone;
+//   - every picture within 0.5% of 16:9 (16:9 screens, letterboxed boxes,
+//     the 16:9 setting on any screen) keeps the setting's scale on both
+//     axes, and Auto there is AutoRenderScale's, exactly as before;
+//   - Auto takes the native shape only within its budget (the Deck's 1x10/9
+//     at 4, an ultrawide's 2.6875x2 at 6), else keeps AutoRenderScale's.
+// Planted bugs this catches (each tried): rows from the 720 rows instead of
+// the columns (1x on the Deck 1x1), the 16:9 margin dropped (a 1366x768 box
+// gets 1281/1280 columns), the budget unchecked (a MacBook's Auto 2x2.232).
+#include <video/picture_fit.h>
+
+#include <cmath>
+#include <cstdio>
+#include <numeric>
+
+using gpu::AxisScale;
+using gpu::RenderScale;
+using video::AutoNativeScale;
+using video::AutoRenderScale;
+using video::FitPicture;
+using video::NativeShape;
+using video::PictureFit;
+
+static int g_failures = 0;
+#define CHECK(cond, ...) do { if (!(cond)) { g_failures++; printf("  FAIL %s:%d: %s: ", __FILE__, __LINE__, #cond); printf(__VA_ARGS__); printf("\n"); } } while (0)
+
+static const AxisScale kOne{ 1, 1 }, kHalf{ 3, 2 }, kTwo{ 2, 1 }, kThree{ 3, 1 };
+static const AxisScale kSettings[] = { kOne, kHalf, kTwo, kThree };  // 1x, 1.5x, 2x, 3x
+
+// The picture Fill Screen gives a W x H screen (the region FrameRegion
+// reports), and the host frame the scale renders: its 1280x720 guest frame
+// at the scale.
+static PictureFit Picture(uint32_t w, uint32_t h, bool fill = true)
+{
+    return FitPicture(w, h, 1280.0f, 720.0f, fill, fill);
+}
+
+static void Native(uint32_t screenW, uint32_t screenH, AxisScale base, uint32_t wantW, uint32_t wantH)
+{
+    const PictureFit fit = Picture(screenW, screenH);
+    const RenderScale s = NativeShape(base, uint32_t(fit.width), uint32_t(fit.height));
+    const uint32_t hostW = s.x.Size(1280), hostH = s.y.Size(720);
+    printf("%ux%u at %s: picture %dx%d, renders %s = %ux%u, shown at %.4f x %.4f\n", screenW, screenH, gpu::AxisName(base).c_str(), fit.width,
+        fit.height, gpu::ScaleName(s).c_str(), hostW, hostH, double(fit.width) / hostW, double(fit.height) / hostH);
+    CHECK(hostW == wantW && hostH == wantH, "%ux%u at %s: %ux%u, want %ux%u", screenW, screenH, gpu::AxisName(base).c_str(), hostW, hostH, wantW,
+        wantH);
+}
+
+int main()
+{
+    printf("The report: a Steam Deck, Fill Screen, 1x\n");
+    {
+        const PictureFit fit = Picture(1280, 800);
+        CHECK(fit.width == 1280 && fit.height == 800 && std::fabs(fit.scaleY - 0.9f) < 1e-6f, "Deck picture %dx%d, view y %.4f", fit.width, fit.height, fit.scaleY);
+        const RenderScale s = NativeShape(kOne, 1280, 800);
+        CHECK((s == RenderScale{ kOne, { 10, 9 } }), "Deck 1x: %s, want 1x10/9", gpu::ScaleName(s).c_str());
+        // The presenter shows the 1280x800 frame on the 1280x800 picture:
+        // 1:1, no resampling (before: 1280x720 at 1 x 1.111).
+        CHECK(s.x.Size(1280) == uint32_t(fit.width) && s.y.Size(720) == uint32_t(fit.height), "Deck 1x frame %ux%u for a %dx%d picture",
+            s.x.Size(1280), s.y.Size(720), fit.width, fit.height);
+        // Its 16:9 setting: a 1280x720 box, 1x1 as before (the crisp case).
+        const PictureFit box = Picture(1280, 800, false);
+        CHECK(box.width == 1280 && box.height == 720, "Deck 16:9 box %dx%d", box.width, box.height);
+        CHECK((NativeShape(kOne, 1280, 720) == RenderScale{ kOne, kOne }), "Deck 16:9 at 1x: %s", gpu::ScaleName(NativeShape(kOne, 1280, 720)).c_str());
+    }
+    Native(1280, 800, kHalf, 1920, 1200);   // 1.5x on the Deck
+    Native(1280, 800, kTwo, 2560, 1600);
+    Native(1920, 1200, kOne, 1280, 800);    // 16:10 1200p: 1x a uniform 1.5x enlargement
+    Native(1920, 1200, kHalf, 1920, 1200);  // and 1:1 at 1.5x
+    Native(2560, 1600, kOne, 1280, 800);
+    Native(2560, 1600, kTwo, 2560, 1600);   // 1:1 at 2x
+    Native(3024, 1898, kOne, 1280, 803);    // a MacBook Pro's fullscreen (below the notch)
+    Native(3024, 1898, kTwo, 2560, 1607);
+    Native(3024, 1890, kTwo, 2560, 1600);
+    Native(3440, 1440, kOne, 1720, 720);    // ultrawide, Hor+: the columns
+    Native(3440, 1440, kTwo, 3440, 1440);   // 1:1 at 2x (Auto gave 3x2: 3840 columns)
+    Native(2560, 1080, kOne, 1707, 720);
+    Native(2560, 1080, kHalf, 2560, 1080);
+    Native(2732, 2048, kOne, 1280, 960);    // iPad Pro 12.9", 4:3
+    Native(1280, 1024, kOne, 1280, 960);    // a 4:3 picture letterboxed on 5:4
+    Native(2160, 1440, kOne, 1280, 853);    // 3:2
+    Native(2796, 1290, kOne, 1561, 720);    // iPhone 15 Pro Max
+
+    printf("Every Vert+ and Hor+ picture, every setting: the base axis as the setting, the other the picture's shape\n");
+    {
+        const uint32_t screens[][2] = { { 1280, 800 }, { 1920, 1200 }, { 2560, 1600 }, { 3024, 1898 }, { 3024, 1890 }, { 2880, 1800 },
+            { 1440, 900 }, { 1680, 1050 }, { 2160, 1440 }, { 3000, 2000 }, { 2732, 2048 }, { 2048, 1536 }, { 1024, 768 }, { 3440, 1440 },
+            { 2560, 1080 }, { 5120, 1440 }, { 3840, 1600 }, { 2796, 1290 }, { 2556, 1179 }, { 1280, 1024 }, { 720, 1280 } };
+        for (const auto& sc : screens)
+        {
+            const PictureFit fit = Picture(sc[0], sc[1]);
+            const bool tall = float(fit.width) / float(fit.height) < 16.0f / 9.0f;
+            for (const AxisScale& base : kSettings)
+            {
+                const RenderScale s = NativeShape(base, uint32_t(fit.width), uint32_t(fit.height));
+                const AxisScale& kept = tall ? s.x : s.y;
+                const AxisScale& grown = tall ? s.y : s.x;
+                CHECK(kept == base, "%ux%u at %s: kept axis %s", sc[0], sc[1], gpu::AxisName(base).c_str(), gpu::AxisName(kept).c_str());
+                CHECK(grown.Value() > base.Value(), "%ux%u at %s: extended axis %s", sc[0], sc[1], gpu::AxisName(base).c_str(),
+                    gpu::AxisName(grown).c_str());
+                // The frame's shape is the picture's within half a host pixel
+                // of the extended axis.
+                const double hostW = s.x.Size(1280), hostH = s.y.Size(720);
+                const double want = tall ? hostW * fit.height / fit.width : hostH * fit.width / fit.height;
+                CHECK(std::fabs((tall ? hostH : hostW) - want) <= 0.5, "%ux%u at %s: %.0fx%.0f for a %dx%d picture", sc[0], sc[1],
+                    gpu::AxisName(base).c_str(), hostW, hostH, fit.width, fit.height);
+                // Reduced (a block or a texel axis), at most 3x's 6 (32:9 at 3x).
+                CHECK(std::gcd(grown.num, grown.den) == 1 && grown.num <= 6 * grown.den, "%ux%u: %u/%u", sc[0], sc[1], grown.num, grown.den);
+            }
+        }
+    }
+
+    printf("16:9 pictures (within 0.5%%): the setting's scale both ways, Auto as AutoRenderScale, exactly as before\n");
+    {
+        // 16:9 screens, the boxes the 16:9 setting gives other screens, and
+        // boxes rounded a pixel off 16:9.
+        const uint32_t boxes[][2] = { { 1280, 720 }, { 1920, 1080 }, { 2560, 1440 }, { 3840, 2160 }, { 1365, 768 }, { 1366, 768 },
+            { 1360, 768 }, { 3024, 1701 }, { 3024, 1700 }, { 2560, 1439 }, { 1279, 720 }, { 2732, 1536 }, { 3440, 1935 }, { 640, 360 } };
+        for (const auto& b : boxes)
+        {
+            for (const AxisScale& base : kSettings)
+            {
+                const RenderScale s = NativeShape(base, b[0], b[1]);
+                CHECK((s == RenderScale{ base, base }), "%ux%u at %s: %s", b[0], b[1], gpu::AxisName(base).c_str(), gpu::ScaleName(s).c_str());
+            }
+            for (uint32_t budget = 1; budget <= 9; budget++)
+            {
+                uint32_t sx = 0, sy = 0;
+                AutoRenderScale(b[0], b[1], budget, sx, sy);
+                const RenderScale s = AutoNativeScale(b[0], b[1], budget);
+                CHECK(s == RenderScale::Whole(sx, sy), "%ux%u budget %u: Auto %s, before %ux%u", b[0], b[1], budget, gpu::ScaleName(s).c_str(), sx, sy);
+            }
+        }
+        // The 16:9 setting on other screens letterboxes a 16:9 box: the same.
+        const uint32_t screens[][2] = { { 1280, 800 }, { 3024, 1898 }, { 3440, 1440 }, { 2732, 2048 }, { 2796, 1290 } };
+        for (const auto& sc : screens)
+        {
+            const PictureFit box = Picture(sc[0], sc[1], false);
+            for (const AxisScale& base : kSettings)
+                CHECK((NativeShape(base, uint32_t(box.width), uint32_t(box.height)) == RenderScale{ base, base }), "%ux%u 16:9 box %dx%d at %s",
+                    sc[0], sc[1], box.width, box.height, gpu::AxisName(base).c_str());
+        }
+        // No picture yet: the setting's scale.
+        CHECK((NativeShape(kTwo, 0, 0) == RenderScale{ kTwo, kTwo }), "no region");
+    }
+
+    printf("Auto: the native shape within the budget, else as before\n");
+    {
+        struct Case { uint32_t w, h, budget; RenderScale want; const char* what; };
+        const Case cases[] = {
+            { 1280, 800, 4, { kOne, { 10, 9 } }, "Steam Deck: 1280x800" },
+            { 3440, 1440, 6, { { 43, 16 }, kTwo }, "ultrawide on a discrete GPU: 3440x1440 in place of 3x2" },
+            { 3440, 1440, 4, RenderScale::Whole(2, 2), "ultrawide, integrated: 2.6875x2 is over 4, so 2x2" },
+            { 2560, 1600, 6, { kTwo, { 20, 9 } }, "1600p, discrete: 2560x1600 in place of 2x2" },
+            { 1920, 1200, 6, { kTwo, { 20, 9 } }, "1200p, discrete: 2560x1600" },
+            { 1920, 1200, 4, RenderScale::Whole(2, 2), "1200p, integrated: 2x2.222 is over 4" },
+            { 3024, 1898, 4, RenderScale::Whole(2, 2), "MacBook Pro fullscreen, M1 Pro: 2x2.232 is over 4" },
+            { 3024, 1898, 9, RenderScale::Whole(3, 3), "MacBook Pro fullscreen, M3 Max: 3x3.347 is over 9" },
+            { 2732, 2048, 1, RenderScale::Whole(1, 1), "iPad: budget 1" },
+            { 2796, 1290, 1, RenderScale::Whole(1, 1), "iPhone: budget 1" },
+            { 1280, 960, 4, { kOne, { 4, 3 } }, "a 4:3 picture on 1280x1024: 1280x960, 1:1, in place of 1x2's 1440 rows" },
+        };
+        for (const Case& c : cases)
+        {
+            const RenderScale s = AutoNativeScale(c.w, c.h, c.budget);
+            printf("  %ux%u budget %u: %s (%s)\n", c.w, c.h, c.budget, gpu::ScaleName(s).c_str(), c.what);
+            CHECK(s == c.want, "%s: %s, want %s", c.what, gpu::ScaleName(s).c_str(), gpu::ScaleName(c.want).c_str());
+        }
+    }
+
+    if (g_failures)
+    {
+        printf("%d FAILED\n", g_failures);
+        return 1;
+    }
+    printf("all passed\n");
+    return 0;
+}
diff --git a/tests/pcie_link_test.cpp b/tests/pcie_link_test.cpp
new file mode 100644
index 0000000..7b8b1bd
--- /dev/null
+++ b/tests/pcie_link_test.cpp
@@ -0,0 +1,92 @@
+// Tests for gpu::pcie (runtime/gpu/pcie_link.h): a discrete GPU's PCIe link
+// read from a sysfs-shaped folder, and how the logs name it. From the repo root:
+//   clang++ -std=c++20 -O2 -Iruntime tests/pcie_link_test.cpp -o build/pcie_link_test
+//   build/pcie_link_test
+// Issue #40's shape: an RTX 5060 Ti (PCIe 5.0 x8) in a Ryzen 5600G's PCIe
+// 3.0 x16 slot, idling at 2.5 GT/s.
+#include <gpu/pcie_link.h>
+
+#include <cstdio>
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+#include <string>
+
+using namespace gpu::pcie;
+
+static int g_failures = 0;
+#define CHECK(cond, ...) do { if (!(cond)) { g_failures++; printf("  FAIL %s:%d: %s: ", __FILE__, __LINE__, #cond); printf(__VA_ARGS__); printf("\n"); } } while (0)
+
+static void Put(const std::filesystem::path& p, const char* text)
+{
+    std::ofstream(p) << text;
+}
+
+static void Parsing()
+{
+    CHECK(ParseSpeed("8.0 GT/s PCIe") == 8.0, "8.0 GT/s PCIe");
+    CHECK(ParseSpeed("2.5 GT/s PCIe") == 2.5, "2.5");
+    CHECK(ParseSpeed("32.0 GT/s PCIe") == 32.0, "32");
+    CHECK(ParseSpeed("8 GT/s") == 8.0, "older kernels' form");
+    CHECK(ParseSpeed("Unknown") == 0 && ParseSpeed("") == 0 && ParseSpeed("8") == 0, "not a speed");
+    CHECK(ParseWidth("8") == 8 && ParseWidth("16\n") == 16 && ParseWidth("x4") == 4, "widths");
+    CHECK(ParseWidth("") == 0 && ParseWidth("0") == 0 && ParseWidth("255") == 0, "not a width");
+    CHECK(Generation(2.5) == 1 && Generation(5) == 2 && Generation(8) == 3 && Generation(16) == 4 && Generation(32) == 5 &&
+        Generation(64) == 6 && Generation(12) == 0, "generations");
+    CHECK(Name(8, 8) == "PCIe 3.0 x8", "%s", Name(8, 8).c_str());
+    CHECK(Name(12, 4) == "PCIe 12.0 GT/s x4", "%s", Name(12, 4).c_str());
+    CHECK(SysfsDir(0, 1, 0, 0) == "/sys/bus/pci/devices/0000:01:00.0", "%s", SysfsDir(0, 1, 0, 0).c_str());
+    CHECK(SysfsDir(0x10, 0xc1, 0x1f, 7, "/x") == "/x/0010:c1:1f.7", "%s", SysfsDir(0x10, 0xc1, 0x1f, 7, "/x").c_str());
+}
+
+static void Folder(const std::filesystem::path& root)
+{
+    // The slot (root port) and the GPU under it, as /sys/devices lays them out.
+    std::filesystem::path port = root / "0000:00:01.1", gpu = port / "0000:01:00.0";
+    std::filesystem::create_directories(gpu);
+    Put(port / "max_link_speed", "8.0 GT/s PCIe\n");
+    Put(port / "max_link_width", "16\n");
+    Put(gpu / "max_link_speed", "32.0 GT/s PCIe\n");
+    Put(gpu / "max_link_width", "8\n");
+    Put(gpu / "current_link_speed", "2.5 GT/s PCIe\n");
+    Put(gpu / "current_link_width", "8\n");
+    Link l = Read(gpu.string());
+    CHECK(l.Known() && l.BestGts() == 8.0 && l.BestWidth() == 8, "best %.1f x%d", l.BestGts(), l.BestWidth());
+    std::string d = Describe(l);
+    printf("issue #40's shape: %s\n", d.c_str());
+    CHECK(d == "PCIe 3.0 x8 at most (the GPU PCIe 5.0 x8, its slot PCIe 3.0 x16; now PCIe 1.0 x8)", "%s", d.c_str());
+
+    // A GPU at its best in a PCIe 4.0 x16 slot.
+    Put(port / "max_link_speed", "16.0 GT/s PCIe\n");
+    Put(gpu / "max_link_speed", "16.0 GT/s PCIe\n");
+    Put(gpu / "max_link_width", "16\n");
+    Put(gpu / "current_link_speed", "16.0 GT/s PCIe\n");
+    Put(gpu / "current_link_width", "16\n");
+    d = Describe(Read(gpu.string()));
+    CHECK(d == "PCIe 4.0 x16 at most (the GPU PCIe 4.0 x16, its slot PCIe 4.0 x16; now PCIe 4.0 x16)", "%s", d.c_str());
+
+    // No port files (a virtual bus), no current link: what is known.
+    std::filesystem::remove(port / "max_link_speed");
+    std::filesystem::remove(gpu / "current_link_speed");
+    d = Describe(Read(gpu.string()));
+    CHECK(d == "PCIe 4.0 x16 at most (the GPU PCIe 4.0 x16)", "%s", d.c_str());
+
+    // Nothing there (not Linux, or no such device): empty, nothing logged.
+    CHECK(Describe(Read((root / "missing").string())).empty(), "missing folder described");
+}
+
+int main()
+{
+    Parsing();
+    std::filesystem::path root = std::filesystem::temp_directory_path() / ("pcie_link_test_" + std::to_string(std::rand()) + std::to_string(long(&g_failures) & 0xFFFF));
+    std::filesystem::remove_all(root);
+    Folder(root);
+    std::filesystem::remove_all(root);
+    if (g_failures)
+    {
+        printf("%d FAILED\n", g_failures);
+        return 1;
+    }
+    printf("all passed\n");
+    return 0;
+}
diff --git a/tests/render_scale_test.cpp b/tests/render_scale_test.cpp
index 9609aea..1b95bb8 100644
--- a/tests/render_scale_test.cpp
+++ b/tests/render_scale_test.cpp
@@ -14,13 +14,23 @@
 //     front-buffer untiles sample for sample, also from a texture that
 //     starts at a page inside it, through both resolve paths (per thread
 //     and coalesced, modelled as the shader does them);
+//   - texel axes (a den above 2: a Steam Deck's native rows 10/9 at 1x,
+//     GitHub #34, and the other screens' rows and columns): edges where
+//     the rasteriser puts them, every host pixel one owner, the inverse,
+//     the depth sample, the box filter's weights, the slot layout (each
+//     texel its stride of samples), and the same round trips at 1x, 1.5x
+//     and 2x on 16:10, a MacBook's 803 rows, 4:3 and ultrawide columns,
+//     mixed with a 3/2 or whole other axis; a reader from another first
+//     texel still reads its own texel's samples;
 //   - NFSMW_RENDER_SCALE's parse and the settings' half steps;
 //   - with renderer.cpp's path (ctest passes it): the shaders that read or
 //     write the scaled memory splice the shared code in.
 // Planted bugs this catches (each tried): sbBlockIndex keeping bit 2,
 // sbHostEdge rounding to nearest, sbOwner off by one, sbOverlap's upper
 // bound one pixel short, a coalesced group's block index taken from the
-// pixel (not the word), the untile's block corner not multiplied by den.
+// pixel (not the word), the untile's block corner not multiplied by den;
+// for texel axes: sbHostEdge flooring, sbStride rounding down, a writer
+// counting from the rectangle (not srcGuest), padding samples left unwritten.
 #include <gpu/render_scale.h>
 
 #include <cstdio>
@@ -247,14 +257,110 @@ struct Pool
     }
 };
 
+// A cached scaled texture a resolve stores into as well (the shader's
+// SCALED_FUSE): the destination's texel 0,0 is its (texX, texY); guest size
+// w x h; its host image, row by row (host width hw).
+struct Hosted
+{
+    uint32_t texX = 0, texY = 0, w = 0, h = 0, hw = 0;
+    std::vector<uint32_t>* image = nullptr;
+    // Stores per host texel this resolve (each host texel is one sample's:
+    // a second store is a race between threads on the GPU), and stores
+    // outside the image.
+    std::vector<uint8_t>* stores = nullptr;
+    uint32_t* outside = nullptr;
+};
+
+// The shader's store into the hosted texture of sample (i, j) of the
+// destination's texel (x, y) (sub in its block).
+static void HostStore(const Hosted* t, const RenderScale& r, uint32_t x, uint32_t y, uint32_t subX, uint32_t subY, uint32_t i, uint32_t j,
+    uint32_t v)
+{
+    if (!t)
+        return;
+    uint32_t tx = x + t->texX, ty = y + t->texY;
+    if (tx >= t->w || ty >= t->h)
+        return;
+    uint32_t hx = G.sbReaderHost(tx, subX, i, r.x.num, r.x.den), hy = G.sbReaderHost(ty, subY, j, r.y.num, r.y.den);
+    if (hx == ~0u || hy == ~0u)
+        return;
+    if (hx >= t->hw || size_t(hy) * t->hw + hx >= t->image->size())
+    {
+        ++*t->outside;
+        return;
+    }
+    (*t->image)[size_t(hy) * t->hw + hx] = v;
+    (*t->stores)[size_t(hy) * t->hw + hx]++;
+}
+
 // A resolve of guest rectangle [x0, x1) x [y0, y1) (of a host picture
 // `src`, srcW wide, at the pool's scale) into the tiled surface at `base`,
 // `pitch`: the shader's scaled writes, per thread (coalesced false) or a
 // 32x2 group at a time through shared memory (coalesced true).
+//   With a texel axis, the shader's SB_TEXEL code: strides, and each
+//   pixel's host pixels from its place in the source (srcGuest = x0, y0:
+//   the picture is the screen's, as untiled rendering's targets are).
+//   hosted: also into that scaled texture. srcDY: the source's rows are
+//   the destination's + srcDY (a destination base whole tile rows into
+//   the surface, its rectangle from row 0; texel axes only).
 static void Resolve(Pool& pool, const std::vector<uint32_t>& src, uint32_t srcW, uint32_t base, uint32_t pitch, uint32_t x0, uint32_t y0,
-    uint32_t x1, uint32_t y1, bool coalesced)
+    uint32_t x1, uint32_t y1, bool coalesced, const Hosted* hosted = nullptr, uint32_t srcDY = 0)
 {
     const RenderScale& r = pool.scale;
+    if (r.x.Texel() || r.y.Texel())
+    {
+        const uint32_t nx = r.x.num, ny = r.y.num, dx = r.x.den, dy = r.y.den;
+        const uint32_t sX = G.sbStride(nx, dx), s = sX * G.sbStride(ny, dy);
+        const uint32_t slotWords = r.SlotWords();
+        const uint32_t lx = G.sbLayoutDen(dx), ly = G.sbLayoutDen(dy);  // the pipeline's kDen
+        const size_t srcH = src.size() / srcW;
+        auto thread = [&](uint32_t gx, uint32_t gy, uint32_t l, std::vector<uint32_t>* samples, std::vector<uint32_t>* offsets) {
+            bool inside = gx < x1 - x0 && gy < y1 - y0;
+            uint32_t a = base + Tiled2D(x0 + gx, y0 + gy, pitch, 2);
+            uint32_t slot = inside ? pool.Slot(a >> 12) : 0;
+            uint32_t k = (a & 4095) >> 2;
+            uint32_t o = (slot - 1) * slotWords + G.sbBlockIndex(k, dx, dy) * s;
+            uint32_t subX = G.sbSubX(k, dx), subY = G.sbSubY(k, dy);
+            uint32_t i0 = G.sbSampleLo(subX, nx, dx), i1 = G.sbSampleHi(subX, nx, dx);
+            uint32_t j0 = G.sbSampleLo(subY, ny, dy), j1 = G.sbSampleHi(subY, ny, dy);
+            uint32_t lb = G.sbBlockIndex(l, lx, ly);
+            uint32_t gX = x0 + gx, gY = y0 + gy + srcDY;  // srcGuest + the pixel
+            if (slot != 0)
+                for (uint32_t j = j0; j < j1; j++)
+                    for (uint32_t i = i0; i < i1; i++)
+                    {
+                        uint32_t cx = std::min<uint32_t>(G.sbSampleHost(gX, subX, i, nx, dx), srcW - 1);
+                        uint32_t cy = std::min<uint32_t>(G.sbSampleHost(gY, subY, j, ny, dy), uint32_t(srcH - 1));
+                        uint32_t v = src[size_t(cy) * srcW + cx];
+                        HostStore(hosted, r, x0 + gx, y0 + gy, subX, subY, i, j, v);
+                        if (samples)
+                            (*samples)[lb * s + j * sX + i] = v;
+                        else
+                            pool.words[o + j * sX + i] = v;
+                    }
+            if (offsets && subX == 0 && subY == 0)
+                (*offsets)[lb] = slot != 0 ? o : ~0u;
+        };
+        if (!coalesced)
+        {
+            for (uint32_t gy = 0; gy < y1 - y0; gy++)
+                for (uint32_t gx = 0; gx < x1 - x0; gx++)
+                    thread(gx, gy, 0, nullptr, nullptr);
+            return;
+        }
+        CHECK(64 / (lx * ly) * s <= 64 * 16, "%s: a coalesced group's %u samples", gpu::ScaleName(r).c_str(), 64 / (lx * ly) * s);
+        for (uint32_t wy = 0; wy < (y1 - y0 + 1) / 2; wy++)
+            for (uint32_t wx = 0; wx < (x1 - x0 + 31) / 32; wx++)
+            {
+                std::vector<uint32_t> samples(64 * 16, 0x5EED5EED), offsets(64, ~0u);
+                for (uint32_t l = 0; l < 64; l++)
+                    thread(wx * 32 + ((l & 3) | ((l >> 3) << 2)), wy * 2 + ((l >> 2) & 1), l, &samples, &offsets);
+                for (uint32_t q = 0; q < 64 / (lx * ly) * s; q++)
+                    if (uint32_t po = offsets[q / s]; po != ~0u)
+                        pool.words[po + q % s] = samples[q];
+            }
+        return;
+    }
     const uint32_t nx = r.x.num, ny = r.y.num, dx = r.x.den, dy = r.y.den, s = nx * ny;
     const uint32_t slotWords = r.SlotWords();
     const int32_t originX = int32_t(r.x.Edge(x0)), originY = int32_t(r.y.Edge(y0));
@@ -276,6 +382,7 @@ static void Resolve(Pool& pool, const std::vector<uint32_t>& src, uint32_t srcW,
                 for (uint32_t i = i0; i < i1; i++)
                 {
                     uint32_t v = src[size_t(cy + int32_t(j)) * srcW + uint32_t(cx + int32_t(i))];
+                    HostStore(hosted, r, x, y, subX, subY, i, j, v);
                     if (samples)
                         (*samples)[lb * s + j * nx + i] = v;
                     else
@@ -309,13 +416,13 @@ static void Resolve(Pool& pool, const std::vector<uint32_t>& src, uint32_t srcW,
 static uint32_t Read(const Pool& pool, uint32_t base, uint32_t pitch, uint32_t hx, uint32_t hy)
 {
     const RenderScale& r = pool.scale;
-    uint32_t bx = hx / r.x.num, by = hy / r.y.num;
-    uint32_t a = base + Tiled2D(bx * r.x.den, by * r.y.den, pitch, 2);
+    uint32_t tx = G.sbBlockTexel(hx, r.x.num, r.x.den), ty = G.sbBlockTexel(hy, r.y.num, r.y.den);
+    uint32_t a = base + Tiled2D(tx, ty, pitch, 2);
     uint32_t slot = pool.table[a >> 12];
     if (!slot)
         return 0;
-    return pool.words[size_t(slot - 1) * r.SlotWords() + G.sbSampleWord((a & 4095) >> 2, hx - bx * r.x.num, hy - by * r.y.num, r.x.num,
-        r.y.num, r.x.den, r.y.den)];
+    return pool.words[size_t(slot - 1) * r.SlotWords() + G.sbSampleWord((a & 4095) >> 2, G.sbBlockSample(hx, r.x.num, r.x.den),
+        G.sbBlockSample(hy, r.y.num, r.y.den), r.x.num, r.y.num, r.x.den, r.y.den)];
 }
 
 static void TestRoundTrip()
@@ -360,6 +467,178 @@ static void TestRoundTrip()
         }
 }
 
+
+// Texel axes (a den above 2): the scales native rows and columns give
+// (video::NativeShape): 16:10 at 1x, 1.5x, 2x, 3x (10/9, 5/3, 20/9, 10/3),
+// a MacBook's 803 and 1607 rows (803/720, 1607/720), 4:3 (4/3, 8/3), an
+// ultrawide's 1720 and 3440 columns (43/32, 43/16), a 19.5:9 phone's 1561.
+static const AxisScale kTexelAxes[] = { { 10, 9 }, { 5, 3 }, { 20, 9 }, { 10, 3 }, { 803, 720 }, { 1607, 720 }, { 4, 3 }, { 8, 3 },
+    { 43, 32 }, { 43, 16 }, { 1561, 1280 } };
+
+static void TestTexelAxis()
+{
+    printf("texel axes: edges where the rasteriser puts them, owners, inverse, depth sample, weights\n");
+    for (const AxisScale& a : kTexelAxes)
+    {
+        const uint32_t n = a.num, d = a.den;
+        CHECK(a.Texel(), "%u/%u isn't a texel axis", n, d);
+        // Guest edge g: the first host pixel whose centre lies at or past
+        // g n / d (a pixel-aligned quad's first row: the top-left rule).
+        for (uint32_t g = 0; g < 4096; g++)
+        {
+            uint32_t e = G.sbHostEdge(g, n, d);
+            CHECK(uint64_t(2 * e + 1) * d >= uint64_t(2) * g * n && (e == 0 || uint64_t(2 * e - 1) * d < uint64_t(2) * g * n),
+                "%u/%u: edge %u -> %u", n, d, g, e);
+            CHECK(G.sbGuestEdge(e, n, d) == g, "%u/%u: edge %u -> %u -> %u", n, d, g, e, G.sbGuestEdge(e, n, d));
+            CHECK(a.Size(g) == e, "%u/%u: size of %u is %u, not its edge %u", n, d, g, a.Size(g), e);
+            // A guest pixel owns one or more host pixels, at most its stride.
+            uint32_t span = G.sbHostEdge(g + 1, n, d) - e;
+            CHECK(span >= 1 && span <= a.Stride(), "%u/%u: guest %u spans %u (stride %u)", n, d, g, span, a.Stride());
+            // The depth sample is one of its own.
+            uint32_t c = G.sbCenterHost(g, n, d);
+            CHECK(c >= e && c < G.sbHostEdge(g + 1, n, d), "%u/%u: depth sample of %u is %u, outside %u..%u", n, d, g, c, e,
+                G.sbHostEdge(g + 1, n, d));
+        }
+        for (uint32_t h = 0; h < 4096; h++)
+        {
+            uint32_t g = G.sbOwner(h, n, d);
+            CHECK(G.sbHostEdge(g, n, d) <= h && h < G.sbHostEdge(g + 1, n, d), "%u/%u: host %u: owner %u spans %u..%u", n, d, h, g,
+                G.sbHostEdge(g, n, d), G.sbHostEdge(g + 1, n, d));
+            CHECK(G.sbBlockTexel(h, n, d) == g && G.sbBlockSample(h, n, d) == h - G.sbHostEdge(g, n, d), "%u/%u: host %u: texel %u sample %u",
+                n, d, h, G.sbBlockTexel(h, n, d), G.sbBlockSample(h, n, d));
+        }
+        // Weights: num a guest pixel, den a host pixel.
+        for (uint32_t g = 0; g < 300; g++)
+        {
+            uint32_t sum = 0;
+            for (uint32_t h = g * n / d; h < G.sbHostSize(g + 1, n, d); h++)
+                sum += G.sbOverlap(g, h, n, d);
+            CHECK(sum == n, "%u/%u: guest %u weighs %u", n, d, g, sum);
+        }
+        // A writer's sample i of guest g: its own host pixels, then its last.
+        for (uint32_t g = 0; g < 300; g++)
+            for (uint32_t i = G.sbSampleLo(0, n, d); i < G.sbSampleHi(0, n, d); i++)
+            {
+                uint32_t h = G.sbSampleHost(g, 0, i, n, d);
+                CHECK(G.sbOwner(h, n, d) == g, "%u/%u: guest %u sample %u is host %u, owned by %u", n, d, g, i, h, G.sbOwner(h, n, d));
+            }
+    }
+    // The ones the screens give.
+    const AxisScale deck{ 10, 9 };
+    CHECK(deck.Size(720) == 800 && deck.Edge(256) == 284 && deck.Edge(512) == 569 && deck.Stride() == 2,
+        "10/9: 720 rows -> %u, strips at %u and %u, stride %u", deck.Size(720), deck.Edge(256), deck.Edge(512), deck.Stride());
+    CHECK((AxisScale{ 5, 3 }.Size(720) == 1200) && (AxisScale{ 20, 9 }.Size(720) == 1600) && (AxisScale{ 803, 720 }.Size(720) == 803) &&
+        (AxisScale{ 43, 32 }.Size(1280) == 1720) && (AxisScale{ 43, 16 }.Size(1280) == 3440), "native sizes");
+    // The scaled memory: each texel its stride, the slot all of them.
+    for (const AxisScale& t : kTexelAxes)
+        for (const AxisScale& other : { AxisScale{ 1, 1 }, AxisScale{ 3, 2 }, AxisScale{ 2, 1 }, AxisScale{ 3, 1 } })
+            for (bool texelY : { true, false })
+            {
+                RenderScale r = texelY ? RenderScale{ other, t } : RenderScale{ t, other };
+                const uint32_t words = r.SlotWords();
+                const uint32_t lx = G.sbLayoutDen(r.x.den), ly = G.sbLayoutDen(r.y.den);
+                CHECK(words == 1024 / (lx * ly) * r.x.Stride() * r.y.Stride(), "%s: %u words", gpu::ScaleName(r).c_str(), words);
+                std::vector<uint32_t> hits(words, 0);
+                for (uint32_t w = 0; w < 1024; w++)
+                {
+                    uint32_t subX = G.sbSubX(w, r.x.den), subY = G.sbSubY(w, r.y.den);
+                    for (uint32_t j = G.sbSampleLo(subY, r.y.num, r.y.den); j < G.sbSampleHi(subY, r.y.num, r.y.den); j++)
+                        for (uint32_t i = G.sbSampleLo(subX, r.x.num, r.x.den); i < G.sbSampleHi(subX, r.x.num, r.x.den); i++)
+                        {
+                            uint32_t k = G.sbSampleWord(w, i, j, r.x.num, r.y.num, r.x.den, r.y.den);
+                            if (k < words)
+                                hits[k]++;
+                            else
+                                CHECK(false, "%s: word %u sample %u,%u at %u of %u", gpu::ScaleName(r).c_str(), w, i, j, k, words);
+                        }
+                }
+                uint32_t bad = 0;
+                for (uint32_t k = 0; k < words; k++)
+                    bad += hits[k] != 1;
+                CHECK(bad == 0, "%s: %u slot words not written exactly once", gpu::ScaleName(r).c_str(), bad);
+            }
+    // 1x10/9: 2 words a texel, 8 KB a page.
+    CHECK((RenderScale{ { 1, 1 }, deck }.SlotWords() == 2048), "1x10/9: %u words a page", (RenderScale{ { 1, 1 }, deck }.SlotWords()));
+}
+
+// The round trip of TestRoundTrip at the native scales: the scene's strips
+// and halves resolved, the whole texture read back sample for sample; the
+// right-half texture (its own first texel 640 columns in) sample for sample
+// where 640 columns are whole host ones, else each host texel still one of
+// its own texel's samples.
+static void TestTexelRoundTrip()
+{
+    printf("texel axes: resolved in strips and halves, read back sample for sample\n");
+    const uint32_t W = 1280, H = 720, pitch = 1280;
+    const RenderScale scales[] = {
+        { { 1, 1 }, { 10, 9 } },     // Steam Deck 1x
+        { { 3, 2 }, { 5, 3 } },      // 1.5x on 16:10: 1920x1200
+        { { 2, 1 }, { 20, 9 } },     // 2x: 2560x1600
+        { { 3, 1 }, { 10, 3 } },     // 3x: 3840x2400
+        { { 1, 1 }, { 803, 720 } },  // a MacBook's 3024x1898 at 1x
+        { { 2, 1 }, { 1607, 720 } }, // and 2x
+        { { 1, 1 }, { 4, 3 } },      // 4:3
+        { { 43, 32 }, { 1, 1 } },    // 3440x1440 at 1x: 1720x720
+        { { 43, 16 }, { 2, 1 } },    // and 2x: 3440x1440
+        { { 1561, 1280 }, { 1, 1 } },// a 19.5:9 phone at 1x
+        { { 5, 2 }, { 1, 1 } },      // a 2.5x block axis (NativeShape can give one)
+    };
+    for (const RenderScale& r : scales)
+        for (bool coalesced : { false, true })
+        {
+            const uint32_t HW = r.x.Size(W), HH = r.y.Size(H);
+            std::vector<uint32_t> src(size_t(HW) * HH);
+            for (uint32_t j = 0; j < HH; j++)
+                for (uint32_t i = 0; i < HW; i++)
+                    src[size_t(j) * HW + i] = (j << 16) | i;
+            Pool pool(r, 1024);
+            const uint32_t base = 0x00400000;
+            Resolve(pool, src, HW, base, pitch, 0, 0, W, 256, coalesced);
+            Resolve(pool, src, HW, base, pitch, 0, 256, 640, 512, coalesced);
+            Resolve(pool, src, HW, base, pitch, 640, 256, W, 512, coalesced);
+            Resolve(pool, src, HW, base, pitch, 0, 512, W, H, coalesced);
+            uint32_t wrong = 0, first = ~0u;
+            for (uint32_t j = 0; j < HH; j++)
+                for (uint32_t i = 0; i < HW; i++)
+                    if (Read(pool, base, pitch, i, j) != src[size_t(j) * HW + i] && wrong++ == 0)
+                        first = (j << 16) | i;
+            CHECK(wrong == 0, "%s %s: %u of %ux%u samples wrong, the first at %u,%u (read %08X)", gpu::ScaleName(r).c_str(),
+                coalesced ? "coalesced" : "per thread", wrong, HW, HH, first & 0xFFFF, first >> 16,
+                first == ~0u ? 0 : Read(pool, base, pitch, first & 0xFFFF, first >> 16));
+            // Every sample of every resolved texel written, the padding past
+            // the ones a texel owns too (no pool fill or shared garbage left).
+            uint32_t unwritten = 0;
+            for (uint32_t y = 0; y < H; y++)
+                for (uint32_t x = 0; x < W; x++)
+                {
+                    uint32_t a = base + Tiled2D(x, y, pitch, 2), w = (a & 4095) >> 2;
+                    uint32_t subX = G.sbSubX(w, r.x.den), subY = G.sbSubY(w, r.y.den);
+                    for (uint32_t j = G.sbSampleLo(subY, r.y.num, r.y.den); j < G.sbSampleHi(subY, r.y.num, r.y.den); j++)
+                        for (uint32_t i = G.sbSampleLo(subX, r.x.num, r.x.den); i < G.sbSampleHi(subX, r.x.num, r.x.den); i++)
+                        {
+                            uint32_t v = pool.words[size_t(pool.table[a >> 12] - 1) * r.SlotWords() +
+                                G.sbSampleWord(w, i, j, r.x.num, r.y.num, r.x.den, r.y.den)];
+                            unwritten += v == 0xDEADBEEF || v == 0x5EED5EED;
+                        }
+                }
+            CHECK(unwritten == 0, "%s %s: %u samples never written", gpu::ScaleName(r).c_str(), coalesced ? "coalesced" : "per thread", unwritten);
+            const uint32_t halfBase = base + 20 * 4096, x0 = r.x.Edge(640u);
+            const bool whole = uint64_t(640) * r.x.num % r.x.den == 0;
+            wrong = 0;
+            for (uint32_t j = 0; j < HH; j++)
+                for (uint32_t i = 0; i < r.x.Size(640); i++)
+                {
+                    uint32_t v = Read(pool, halfBase, pitch, i, j);
+                    if (whole)
+                        wrong += v != src[size_t(j) * HW + x0 + i];
+                    else
+                        wrong += (v >> 16) != j || r.x.Texel() && G.sbOwner(v & 0xFFFF, r.x.num, r.x.den) != 640 + G.sbOwner(i, r.x.num, r.x.den);
+                }
+            CHECK(wrong == 0, "%s %s: the right half's texture has %u wrong samples", gpu::ScaleName(r).c_str(),
+                coalesced ? "coalesced" : "per thread", wrong);
+        }
+}
+
 static void TestParse()
 {
     printf("NFSMW_RENDER_SCALE and the setting's half steps\n");
@@ -374,6 +653,18 @@ static void TestParse()
         { "4", true, RenderScale::Whole(4, 4) },
         { "9", true, RenderScale::Whole(4, 4) },  // clamped, as before
         { "0", true, RenderScale::Whole(1, 1) },  // as before
+        { "1x10/9", true, { { 1, 1 }, { 10, 9 } } },   // native rows (GitHub #34)
+        { "10/9", true, { { 10, 9 }, { 10, 9 } } },
+        { "2x40/18", true, { { 2, 1 }, { 20, 9 } } },  // reduced
+        { "1.5x5/3", true, { kHalf, { 5, 3 } } },
+        { "3/2", true, { kHalf, kHalf } },
+        { "4/2", true, RenderScale::Whole(2, 2) },
+        { "5/2", false, {} },                           // 2.5x, as "2.5"
+        { "9/10", false, {} },                          // below 1
+        { "17/4", false, {} },                          // above 4
+        { "10/0", false, {} },
+        { "10/", false, {} },
+        { "1x10/9x2", false, {} },
         { "2.5", false, {} },
         { "1.25", false, {} },
         { "abc", false, {} },
@@ -400,6 +691,104 @@ static void TestParse()
 }
 
 // The shaders that touch the scaled memory take the shared code.
+// A scaled resolve storing straight into its cached scaled texture (the
+// shader's SCALED_FUSE, sbReaderHost): the texture's host image afterwards is
+// exactly what its untile would read from the pool, every host texel, at
+// every scale above (block and texel axes), through both resolve paths, with
+// the scene resolved in strips and halves, and (texel axes) with strips whose
+// destination base is whole tile rows into the texture (texY).
+static void TestHostedTexture()
+{
+    printf("scaled resolves stored straight into their scaled texture: the untile's texels\n");
+    const uint32_t W = 1280, H = 720, pitch = 1280;
+    const RenderScale scales[] = {
+        { kHalf, kHalf }, { kHalf, { 1, 1 } }, { { 2, 1 }, kHalf }, RenderScale::Whole(2, 2), RenderScale::Whole(3, 2),
+        { { 1, 1 }, { 10, 9 } }, { { 3, 2 }, { 5, 3 } }, { { 2, 1 }, { 20, 9 } }, { { 3, 1 }, { 10, 3 } }, { { 1, 1 }, { 803, 720 } },
+        { { 2, 1 }, { 1607, 720 } }, { { 1, 1 }, { 4, 3 } }, { { 43, 32 }, { 1, 1 } }, { { 43, 16 }, { 2, 1 } }, { { 1561, 1280 }, { 1, 1 } },
+        { { 5, 2 }, { 1, 1 } },
+    };
+    for (const RenderScale& r : scales)
+        for (bool coalesced : { false, true })
+            for (bool offsetStrips : { false, true })
+            {
+                const bool texel = r.x.Texel() || r.y.Texel();
+                if (offsetStrips && !texel)
+                    continue;  // (the model's block path counts the source from the rectangle)
+                const uint32_t HW = r.x.Size(W), HH = r.y.Size(H);
+                std::vector<uint32_t> src(size_t(HW) * HH);
+                for (uint32_t j = 0; j < HH; j++)
+                    for (uint32_t i = 0; i < HW; i++)
+                        src[size_t(j) * HW + i] = (j << 16) | i;
+                Pool pool(r, 1024);
+                const uint32_t base = 0x00400000;
+                std::vector<uint32_t> image(size_t(HW) * HH, 0xDEADBEEF);
+                std::vector<uint8_t> stores(image.size(), 0);
+                uint32_t outside = 0;
+                Hosted t{ 0, 0, W, H, HW, &image, &stores, &outside };
+                Resolve(pool, src, HW, base, pitch, 0, 0, W, 256, coalesced, &t);
+                if (offsetStrips)
+                {
+                    // Rows 256 and 512 through bases 8 and 16 tile rows in
+                    // (40 tiles a row), each rectangle from row 0.
+                    Hosted t2 = t, t3 = t;
+                    t2.texY = 256;
+                    t3.texY = 512;
+                    Resolve(pool, src, HW, base + 8 * 40 * 4096, pitch, 0, 0, W, 256, coalesced, &t2, 256);
+                    Resolve(pool, src, HW, base + 16 * 40 * 4096, pitch, 0, 0, W, H - 512, coalesced, &t3, 512);
+                }
+                else
+                {
+                    Resolve(pool, src, HW, base, pitch, 0, 256, 640, 512, coalesced, &t);
+                    Resolve(pool, src, HW, base, pitch, 640, 256, W, 512, coalesced, &t);
+                    Resolve(pool, src, HW, base, pitch, 0, 512, W, H, coalesced, &t);
+                }
+                uint32_t wrong = 0, first = ~0u;
+                for (uint32_t j = 0; j < HH; j++)
+                    for (uint32_t i = 0; i < HW; i++)
+                        if (image[size_t(j) * HW + i] != Read(pool, base, pitch, i, j) && wrong++ == 0)
+                            first = (j << 16) | i;
+                CHECK(wrong == 0, "%s %s%s: %u of %ux%u host texels differ from the untile's, the first at %u,%u (%08X, untile %08X)",
+                    gpu::ScaleName(r).c_str(), coalesced ? "coalesced" : "per thread", offsetStrips ? ", strips through offset bases" : "",
+                    wrong, HW, HH, first & 0xFFFF, first >> 16, first == ~0u ? 0 : image[size_t(first >> 16) * HW + (first & 0xFFFF)],
+                    first == ~0u ? 0 : Read(pool, base, pitch, first & 0xFFFF, first >> 16));
+                uint32_t twice = 0;
+                for (uint8_t n : stores)
+                    twice += n > 1;
+                CHECK(twice == 0 && outside == 0, "%s %s%s: %u host texels stored more than once, %u stores outside the image",
+                    gpu::ScaleName(r).c_str(), coalesced ? "coalesced" : "per thread", offsetStrips ? ", offset strips" : "", twice, outside);
+                // And the picture's own pixels (the untile's are those, test above).
+                wrong = 0;
+                for (uint32_t j = 0; j < HH; j++)
+                    for (uint32_t i = 0; i < HW; i++)
+                        wrong += image[size_t(j) * HW + i] != src[size_t(j) * HW + i];
+                CHECK(wrong == 0, "%s %s%s: %u host texels aren't the picture's", gpu::ScaleName(r).c_str(),
+                    coalesced ? "coalesced" : "per thread", offsetStrips ? ", offset strips" : "", wrong);
+            }
+}
+
+// The scaled memory's default size: 512 MB on a discrete GPU (as before);
+// on an integrated one 16,384 pages' slots, at most 512 MB.
+static void TestPoolSize()
+{
+    printf("scaled memory: default size\n");
+    const RenderScale deck{ { 1, 1 }, { 10, 9 } };
+    CHECK(gpu::ScaledPoolMegabytes(deck, false) == 128, "Steam Deck 1x10/9: %llu MB", (unsigned long long)gpu::ScaledPoolMegabytes(deck, false));
+    CHECK(gpu::ScaledPoolMegabytes(RenderScale::Whole(2, 2), false) == 256, "2x2 integrated");
+    CHECK(gpu::ScaledPoolMegabytes(RenderScale{ kHalf, kHalf }, false) == 144, "1.5x integrated: %llu",
+        (unsigned long long)gpu::ScaledPoolMegabytes(RenderScale{ kHalf, kHalf }, false));
+    CHECK(gpu::ScaledPoolMegabytes(RenderScale::Whole(3, 2), false) == 384, "3x2 integrated");
+    CHECK(gpu::ScaledPoolMegabytes(RenderScale::Whole(3, 3), false) == 512, "3x3 integrated: capped");
+    for (const RenderScale& r : { deck, RenderScale::Whole(2, 2), RenderScale::Whole(4, 4) })
+        CHECK(gpu::ScaledPoolMegabytes(r, true) == 512, "%s discrete", gpu::ScaleName(r).c_str());
+    // Always at least the 16,384 pages (or the 512 MB cap).
+    for (const RenderScale& r : { deck, RenderScale{ { 2, 1 }, { 20, 9 } }, RenderScale{ { 43, 32 }, { 1, 1 } }, RenderScale{ kHalf, { 5, 3 } } })
+    {
+        const uint64_t mb = gpu::ScaledPoolMegabytes(r, false);
+        CHECK(mb == 512 || (mb << 20) / (4ull * r.SlotWords()) >= 16384, "%s: %llu MB holds too few pages", gpu::ScaleName(r).c_str(),
+            (unsigned long long)mb);
+    }
+}
+
 static void TestShaders(const char* rendererPath)
 {
     printf("renderer.cpp's shaders splice GLSL_SCALE_CODE\n");
@@ -422,6 +811,17 @@ static void TestShaders(const char* rendererPath)
         CHECK(body.find("sbSampleWord") != std::string::npos || body.find("sbBlockIndex") != std::string::npos,
             "%s doesn't use the block layout", shader);
     }
+    // A texel axis's resolve and front shaders take the scale as constants
+    // (SB_FIXED_*: divisions by num and den folded; Steam Deck 1x10/9 spent
+    // ~2 ms a frame dividing by the push constants).
+    for (const char* shader : { "kResolveGlsl", "kFrontGlsl" })
+    {
+        size_t at = text.find(std::string("const char* ") + shader + " = R\"(");
+        size_t end = at == std::string::npos ? at : text.find("\n)\";", at);
+        CHECK(at != std::string::npos && text.substr(at, end - at).find("#ifdef SB_FIXED_NUM_X") != std::string::npos,
+            "%s doesn't take SB_FIXED_*", shader);
+    }
+    CHECK(text.find("#define SB_FIXED_NUM_X {}u") != std::string::npos, "no pipeline defines SB_FIXED_*");
     const std::string glsl = GLSL_SCALE_CODE;
     for (const char* fn : { "uint sbHostEdge(", "uint sbOverlap(", "uint sbCenterHost(", "uint sbBlockIndex(", "uint sbSampleWord(" })
         CHECK(glsl.find(fn) != std::string::npos, "GLSL_SCALE_CODE lacks %s", fn);
@@ -438,6 +838,10 @@ int main(int argc, char** argv)
     TestBoxFilter();
     TestSlotLayout();
     TestRoundTrip();
+    TestTexelAxis();
+    TestTexelRoundTrip();
+    TestHostedTexture();
+    TestPoolSize();
     TestParse();
     if (argc > 1)
         TestShaders(argv[1]);
diff --git a/tests/rumble_note_test.cpp b/tests/rumble_note_test.cpp
new file mode 100644
index 0000000..6fbbda5
--- /dev/null
+++ b/tests/rumble_note_test.cpp
@@ -0,0 +1,170 @@
+// SpeedBreaker tests. GPL-3.0-or-later (see COPYING).
+//
+// The one-time "no rumble over USB" note for an Xbox controller on a Mac
+// (hid/rumble_note.h): when it shows (macOS, an Xbox pad by vendor or name,
+// Apple's GameController route, not wireless, Vibration on, not dismissed)
+// and when it doesn't (a DualSense wired, an Xbox pad over Bluetooth, other
+// platforms); and the dismissal in settings.toml ([app] xbox_usb_rumble_note,
+// user/settings.cpp as the game links it), in a scratch folder (the argument).
+//
+// Build by hand (from the repo root):
+//   c++ -std=c++20 -O2 -UNDEBUG -I runtime tests/rumble_note_test.cpp runtime/user/settings.cpp \
+//     -o build/rumble_note_test
+//   build/rumble_note_test build/rumble_note_scratch
+#include <hid/rumble_note.h>
+#include <user/settings.h>
+
+#include <cstdio>
+#include <filesystem>
+#include <fstream>
+#include <sstream>
+#include <string>
+
+namespace
+{
+    int s_failures = 0;
+
+#define CHECK(cond, ...)                                                    \
+    do                                                                      \
+    {                                                                       \
+        if (!(cond))                                                        \
+        {                                                                   \
+            s_failures++;                                                   \
+            fprintf(stderr, "FAIL %s:%d: %s: ", __FILE__, __LINE__, #cond); \
+            fprintf(stderr, __VA_ARGS__);                                   \
+            fprintf(stderr, "\n");                                          \
+        }                                                                   \
+    } while (0)
+
+    using hid::RumbleNote;
+    using Platform = RumbleNote::Platform;
+    using Connection = RumbleNote::Connection;
+
+    // A wired Xbox Series pad on a Mac as SDL logs it: GameController, connection unknown.
+    RumbleNote::Inputs XboxUsbOnMac()
+    {
+        RumbleNote::Inputs in;
+        in.platform = Platform::Mac;
+        in.driver = 'm';
+        in.connection = Connection::Unknown;
+        in.vendor = 0x045E;
+        in.name = "Xbox Series X Controller";
+        return in;
+    }
+
+    void Expect(const char* what, const RumbleNote::Inputs& in, bool show)
+    {
+        const RumbleNote::Decision d = RumbleNote::Decide(in);
+        printf("  %-52s %s (%s)\n", what, d.show ? "NOTE" : "no note", d.reason);
+        CHECK(d.show == show, "%s: %s", what, d.reason);
+    }
+
+    void WhenItShows()
+    {
+        printf("when the note shows:\n");
+        Expect("Xbox by USB on a Mac (connection unknown)", XboxUsbOnMac(), true);
+        auto in = XboxUsbOnMac();
+        in.connection = Connection::Wired;
+        Expect("Xbox by USB on a Mac (reported wired)", in, true);
+        in = XboxUsbOnMac();
+        in.vendor = 0;
+        Expect("Xbox by name only (vendor unknown)", in, true);
+        in = XboxUsbOnMac();
+        in.vendor = 0x24C6;  // PowerA
+        in.name = "PowerA XBOX Series X Controller";
+        Expect("licensed Xbox pad (\"XBOX\" in the name)", in, true);
+        in = XboxUsbOnMac();
+        in.name = "Controller";
+        Expect("Microsoft vendor, plain name", in, true);
+
+        in = XboxUsbOnMac();
+        in.shownBefore = true;
+        Expect("Xbox by USB on a Mac, dismissed before", in, false);
+        in = XboxUsbOnMac();
+        in.vibration = false;
+        Expect("Xbox by USB on a Mac, Vibration off", in, false);
+
+        // Over Bluetooth the same pad goes through HIDAPI (and rumbles); with
+        // GameController reporting wireless, still none.
+        in = XboxUsbOnMac();
+        in.driver = 'h';
+        in.connection = Connection::Wireless;
+        in.name = "Xbox Wireless Controller";
+        Expect("Xbox over Bluetooth (HIDAPI)", in, false);
+        in.driver = 'm';
+        Expect("Xbox over Bluetooth (GameController, wireless)", in, false);
+        in = XboxUsbOnMac();
+        in.driver = 'h';
+        in.connection = Connection::Wired;
+        Expect("Xbox by USB through HIDAPI (rumbles)", in, false);
+
+        // A DualSense rumbles either way.
+        in = XboxUsbOnMac();
+        in.vendor = 0x054C;
+        in.name = "DualSense Wireless Controller";
+        Expect("DualSense by USB on a Mac", in, false);
+        in.connection = Connection::Wired;
+        in.driver = 'h';
+        Expect("DualSense by USB on a Mac (HIDAPI)", in, false);
+
+        // Other platforms: never.
+        in = XboxUsbOnMac();
+        in.platform = Platform::Other;
+        Expect("Xbox by USB, not macOS", in, false);
+    }
+
+    std::string Read(const std::filesystem::path& file)
+    {
+        std::ifstream f(file);
+        std::stringstream ss;
+        ss << f.rdbuf();
+        return ss.str();
+    }
+
+    // Once: the first decision shows it, the dismissal is recorded, and every
+    // later one (this run, a new load, after a save) doesn't.
+    void Once(const std::filesystem::path& scratch)
+    {
+        printf("shown once (settings.toml):\n");
+        std::error_code ec;
+        std::filesystem::remove_all(scratch, ec);
+        std::filesystem::create_directories(scratch, ec);
+        const std::filesystem::path file = scratch / "settings.toml";
+        std::ofstream(file) << "[app]\nlast_version = \"0.1.8\"\nrefresh_notices = \"90\"\n";
+        CHECK(settings::Load(file), "load");
+        auto in = XboxUsbOnMac();
+        in.shownBefore = settings::RumbleNoteShown();
+        CHECK(RumbleNote::Decide(in).show, "first time");
+        CHECK(settings::RecordRumbleNote(), "record");
+        in.shownBefore = settings::RumbleNoteShown();
+        CHECK(!RumbleNote::Decide(in).show, "again this run");
+        std::string text = Read(file);
+        CHECK(text.find("xbox_usb_rumble_note = true") != std::string::npos && text.find("refresh_notices = \"90\"") != std::string::npos &&
+                text.find("last_version = \"0.1.8\"") != std::string::npos,
+            "file after the record:\n%s", text.c_str());
+        CHECK(settings::Load(file) && settings::RumbleNoteShown(), "reload");
+        CHECK(settings::RecordVersion("0.1.9") && settings::RecordRefreshNotice(144) && settings::Save(), "version, refresh notice, save");
+        text = Read(file);
+        CHECK(text.find("xbox_usb_rumble_note = true") != std::string::npos && text.find("refresh_notices = \"90,144\"") != std::string::npos,
+            "after a save:\n%s", text.c_str());
+        CHECK(settings::Load(file) && settings::RumbleNoteShown(), "reload after a save");
+        // Without the key (a new player, or a hand edit): not shown before, and nothing written.
+        std::ofstream(file) << "[app]\nlast_version = \"0.1.8\"\n";
+        CHECK(settings::Load(file) && !settings::RumbleNoteShown() && settings::RecordVersion("0.1.9"), "plain");
+        text = Read(file);
+        CHECK(text.find("xbox_usb_rumble_note") == std::string::npos, "the key appeared:\n%s", text.c_str());
+        std::ofstream(file) << "[app]\nxbox_usb_rumble_note = \"yes\"\n";
+        CHECK(settings::Load(file) && !settings::RumbleNoteShown(), "not a bool");
+        printf("  shown, recorded, not shown again, kept by a save: %s\n", s_failures ? "see failures" : "ok");
+        std::filesystem::remove_all(scratch, ec);
+    }
+}
+
+int main(int argc, char** argv)
+{
+    const std::filesystem::path scratch = argc > 1 ? std::filesystem::path(argv[1]) : std::filesystem::temp_directory_path() / "rumble_note_test";
+    WhenItShows();
+    Once(scratch);
+    printf(s_failures ? "\n%d FAILED\n" : "\nall passed\n", s_failures);
+    return s_failures ? 1 : 0;
+}