diff --git a/.github/actions/install-linux-packages/action.yml b/.github/actions/install-linux-packages/action.yml
new file mode 100644
index 0000000..a363639
--- /dev/null
+++ b/.github/actions/install-linux-packages/action.yml
@@ -0,0 +1,83 @@
+# Copyright 2026 Han Li and contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+name: Install the Linux packages
+description: >-
+  Installs Ubuntu packages from a cache of their archives, and downloads what the
+  cache lacks eight files at a time, continuing what was cut and trying the next
+  mirror when one is slow, in 15 minutes at most (see install.sh), because the
+  Ubuntu mirror of the runners is slow for some of them at times.
+
+inputs:
+  packages:
+    description: The packages, separated by spaces or new lines.
+    required: true
+
+runs:
+  using: composite
+  steps:
+    - name: Name the cache
+      id: names
+      shell: bash
+      env:
+        PACKAGES: ${{ inputs.packages }}
+      run: |
+        # A cache for each list of packages and each week: a week is long enough
+        # for many runs to use it, and short enough to stay near the versions
+        # of the mirror. The newest cache of any earlier week (or what an
+        # interrupted run saved, see below) starts the cache of a new week,
+        # which install.sh trims.
+        hash="$(echo "$PACKAGES" | tr -s '[:space:]' '\n' | sort -u | sha256sum | cut -c1-16)"
+        echo "prefix=apt-${ImageOS:-ubuntu}-$hash-" >> "$GITHUB_OUTPUT"
+        echo "key=apt-${ImageOS:-ubuntu}-$hash-$(date -u +%G-W%V)" >> "$GITHUB_OUTPUT"
+    - name: Let the cache write the archives
+      shell: bash
+      run: sudo chmod a+rwx /var/cache/apt/archives
+    - name: Restore the archives
+      id: cache
+      uses: actions/cache/restore@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
+      with:
+        path: /var/cache/apt/archives/*.deb
+        key: ${{ steps.names.outputs.key }}
+        restore-keys: ${{ steps.names.outputs.prefix }}
+    - name: Install the packages
+      id: install
+      shell: bash
+      env:
+        PACKAGES: ${{ inputs.packages }}
+      run: |
+        # shellcheck disable=SC2086 # The list is meant to be split.
+        "$GITHUB_ACTION_PATH/install.sh" $PACKAGES
+    # The cache is saved by the user of the runner, and one archive that this user
+    # cannot read fails the whole save (tar did on one archive of Wails, on
+    # 2026-10-23, and nothing was saved). It also holds when the installation failed.
+    - name: Let the cache read the archives
+      if: always()
+      shell: bash
+      run: sudo chmod a+r /var/cache/apt/archives/*.deb || true
+    - name: Save the archives
+      if: steps.install.outcome == 'success' && steps.cache.outputs.cache-hit != 'true'
+      uses: actions/cache/save@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
+      with:
+        path: /var/cache/apt/archives/*.deb
+        key: ${{ steps.names.outputs.key }}
+    # A download that did not finish within its time is not lost: the next run
+    # starts from the archives it got (by the prefix above) instead of from
+    # nothing, so that a run on a slow mirror gets further each time.
+    - name: Save what was downloaded
+      if: always() && steps.install.outcome == 'failure'
+      uses: actions/cache/save@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
+      with:
+        path: /var/cache/apt/archives/*.deb
+        key: ${{ steps.names.outputs.prefix }}partial-${{ github.run_id }}-${{ github.run_attempt }}
diff --git a/.github/actions/install-linux-packages/fetch.sh b/.github/actions/install-linux-packages/fetch.sh
new file mode 100755
index 0000000..feb43d6
--- /dev/null
+++ b/.github/actions/install-linux-packages/fetch.sh
@@ -0,0 +1,149 @@
+#!/usr/bin/env bash
+# Copyright 2026 Han Li and contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Makes one archive of a package available for install.sh, which starts several of
+# these at the same time:
+#
+#   fetch.sh <archive directory> <size> <file name> <hash> <address>...
+#
+# The hash is the one that apt prints, TYPE:digest (SHA256:... with
+# -o Acquire::ForceHash=SHA256). apt checks the hash of what it downloads, but takes
+# an archive that is in the directory with its size for a good one, so that the
+# archive has to be checked here, before it is moved there. An archive that is
+# there already is checked too, and removed when it is wrong, which is what a damaged
+# cache would otherwise break the installation with.
+#
+# The addresses are those of the file on the mirrors, in the order to try them. The
+# download goes to partial/ first, where apt keeps what it is downloading, and
+# continues from what is there, so that a connection that is cut, or dropped for being
+# slow, loses nothing.
+#
+# A connection that gets less than APT_MIN_SPEED bytes a second (262144 by default)
+# for APT_SPEED_TIME seconds (10) is dropped, and the download continues from the next
+# mirror: a mirror is slow for some runners and not for others, and the speed of the
+# next one is not known before it is tried. When every mirror has been slow in turn, a
+# slow download is better than none: the best of them continues, and only a stalled
+# connection is dropped. A file that no mirror sends in three rounds, or that has the
+# wrong hash three times, is given up.
+#
+# APT_DEADLINE, in seconds since the epoch, is the time when the download ends.
+set -uo pipefail
+
+[[ $# -ge 5 ]] || { echo "Usage: fetch.sh <archive directory> <size> <file name> <hash> <address>..." >&2; exit 2; }
+
+directory="$1"
+size="$2"
+name="$3"
+hash="$4"
+shift 4
+addresses=("$@")
+deadline="${APT_DEADLINE:?APT_DEADLINE is the time when the download ends, in seconds since the epoch}"
+minimum="${APT_MIN_SPEED:-262144}"
+window="${APT_SPEED_TIME:-10}"
+final="$directory/$name"
+partial="$directory/partial/$name"
+error="$(mktemp)"
+trap 'rm -f "$error"' EXIT
+
+# The size of what has been downloaded.
+have() {
+  stat --format %s "$partial" 2> /dev/null || echo 0
+}
+
+# right <file>: whether the file has the hash that apt printed.
+right() {
+  local tool
+  case "${hash%%:*}" in
+    MD5Sum) tool=md5sum ;;
+    SHA1) tool=sha1sum ;;
+    SHA256) tool=sha256sum ;;
+    SHA512) tool=sha512sum ;;
+    *) return 1 ;;
+  esac
+  [[ "$("$tool" "$1" 2> /dev/null | cut -d ' ' -f 1)" == "${hash#*:}" ]]
+}
+
+if [[ -e "$final" ]]; then
+  if [[ "$(stat --format %s "$final")" -eq "$size" ]] && right "$final"; then
+    exit 0
+  fi
+  echo "$name: the archive in the directory is not the one that apt expects; removed"
+  rm -f "$final"
+fi
+
+fruitless=0
+wrong=0
+last=""
+while true; do
+  if [[ "$(have)" -eq "$size" ]]; then
+    right "$partial" && break
+    echo "$name: the hash is not $hash; starting again"
+    rm -f "$partial"
+    wrong=$((wrong + 1))
+    ((wrong < 3)) || { echo "$name: no mirror sends the right file" >&2; exit 1; }
+    # The mirror that completed it is the last one to try again.
+    addresses=()
+    for address in "$@"; do
+      [[ "$address" == "$last" ]] || addresses+=("$address")
+    done
+    [[ -z "$last" ]] || addresses+=("$last")
+  fi
+  # More than the file has is not a part of it.
+  [[ "$(have)" -le "$size" ]] || rm -f "$partial"
+  start="$(have)"
+  best=""
+  best_gain=0
+  for address in "${addresses[@]}"; do
+    before="$(have)"
+    [[ "$before" -lt "$size" ]] || break
+    left=$((deadline - $(date +%s)))
+    ((left > 0)) || exit 1
+    last="$address"
+    speed="$(curl --fail --silent --show-error --location --connect-timeout 10 --max-time "$left" \
+      --speed-limit "$minimum" --speed-time "$window" --continue-at - \
+      --write-out '%{speed_download}' --output "$partial" "$address" 2> "$error")"
+    status=$?
+    # A server that does not continue a download sends all of the file, which curl
+    # does not take (33): start again.
+    [[ $status -ne 33 ]] || rm -f "$partial"
+    gain=$(($(have) - before))
+    if ((gain > best_gain)); then
+      best="$address"
+      best_gain=$gain
+    fi
+    if [[ "$(have)" -ne "$size" ]]; then
+      host="${address#*://}"
+      echo "$name: $(have) of $size bytes, ${speed%.*} bytes a second from ${host%%/*}: $(tr '\n' ' ' < "$error")"
+    fi
+  done
+  # All of it came, to be checked at the top.
+  [[ "$(have)" -ne "$size" ]] || continue
+  if [[ "$(have)" -gt "$start" ]]; then
+    fruitless=0
+  else
+    fruitless=$((fruitless + 1))
+    ((fruitless < 3)) || { echo "$name: no mirror sends it" >&2; exit 1; }
+  fi
+  # Every mirror was slow in turn, or failed: go on with the best of them.
+  minimum=1000
+  if [[ -n "$best" ]]; then
+    addresses=("$best")
+    for address in "$@"; do
+      [[ "$address" == "$best" ]] || addresses+=("$address")
+    done
+  fi
+  sleep 1
+done
+mv "$partial" "$final"
diff --git a/.github/actions/install-linux-packages/install.sh b/.github/actions/install-linux-packages/install.sh
new file mode 100755
index 0000000..c1a438d
--- /dev/null
+++ b/.github/actions/install-linux-packages/install.sh
@@ -0,0 +1,160 @@
+#!/usr/bin/env bash
+# Copyright 2026 Han Li and contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Installs Ubuntu packages on a runner of GitHub Actions in two steps, which the
+# action next to this file (action.yml) wraps in a cache:
+#
+#   1. Downloads the packages that the cache lacks into /var/cache/apt/archives, in
+#      15 minutes at most. fetch.sh does it, eight files at a time and the largest
+#      first, from the mirrors of the runner: it continues what was cut, tries the
+#      next mirror when one is slow, and checks the hash of every archive, those of
+#      the cache too, because apt takes an archive of the right size for a good one.
+#      Then apt fetches what is left.
+#   2. Installs them from the archives, which needs no network.
+#
+# Why not apt alone: the Ubuntu mirror of the runners is slow for some of them. On
+# 2026-10-23 a job got 40 KB/s for a connection while other jobs of the same minute
+# downloaded 90 MB in seconds, and its 94 MB did not come in 30 minutes (a minute on a
+# good day), which a job of 25 or 45 minutes cannot wait for; a file of 25 MB alone
+# takes 10 minutes at that speed. apt downloads from one mirror, over one connection,
+# one file after the other, however slow it is.
+#
+# Finally it removes the archives of versions that the package lists no longer
+# have, so that the cache does not grow from week to week.
+#
+# Usage: install.sh <package>...
+#
+# Set APT_DOWNLOAD_SECONDS to change the time of the download (900): it has to end
+# before the timeout of the job, for the action to save what was downloaded.
+# APT_PARALLEL is the number of files that are downloaded at the same time (8; 0
+# leaves all of it to apt). fetch.sh has two more, APT_MIN_SPEED and APT_SPEED_TIME.
+set -euo pipefail
+
+[[ $# -gt 0 ]] || { echo "Usage: install.sh <package>..." >&2; exit 2; }
+
+packages=("$@")
+seconds="${APT_DOWNLOAD_SECONDS:-900}"
+parallel="${APT_PARALLEL:-8}"
+here="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+archives=/var/cache/apt/archives
+deadline=$(($(date +%s) + seconds))
+
+# A request that gets no data for 30 seconds fails and is tried again, up to 3
+# times; apt waits for 2 minutes by default. The archives stay where they are
+# after the installation: a runner has no hook that removes them, but a
+# container of Docker has.
+apt_options=(-o Acquire::Retries=3 -o Acquire::http::Timeout=30 -o Acquire::https::Timeout=30
+  -o APT::Keep-Downloaded-Packages=true)
+
+# apt_get <time limit> <arguments...>: apt-get as root, for at most the time (0 is
+# no limit), without questions.
+apt_get() {
+  local time="$1"
+  shift
+  sudo timeout "$time" env DEBIAN_FRONTEND=noninteractive apt-get "${apt_options[@]}" "$@"
+}
+
+# archive_size <file name>: the size of the archive, 0 when it is not there.
+archive_size() {
+  stat --format %s "$archives/$1" 2> /dev/null || echo 0
+}
+
+# missing <list>: the number of archives of the list that are not in the directory
+# with their size.
+missing() {
+  local size name count=0
+  while read -r size name _; do
+    [[ "$(archive_size "$name")" -eq "$size" ]] || count=$((count + 1))
+  done < "$1"
+  echo "$count"
+}
+
+# prefetch: makes the archives that the installation needs available in the
+# directory, and checks the ones that are there already. It only saves time: what it
+# does not fetch, apt does.
+prefetch() {
+  local mirrors list empty line path total before after size name hash address mirror
+  if ! command -v curl > /dev/null; then
+    echo "curl is missing, apt downloads everything."
+    return
+  fi
+  # The runners list their mirrors in a file, one for each line, the best first.
+  mapfile -t mirrors < <(awk 'NF { print $1 }' /etc/apt/apt-mirrors.txt 2> /dev/null)
+  list="$(mktemp)"
+  # apt prints 'address' name size hash for each archive (a SHA256 hash is what
+  # fetch.sh checks), but not for the archives that are in the directory, which it
+  # takes for good ones: it is shown an empty directory, and fetch.sh checks them. The
+  # address of a runner starts with that of the file of the mirrors, which stands for
+  # one of them: the line of an archive has its address on each mirror, for fetch.sh.
+  # The largest come first, so that none of them is the last and alone.
+  empty="$(mktemp -d)"
+  apt_get 2m -o Dir::Cache::Archives="$empty" -o Acquire::ForceHash=SHA256 install --print-uris -y --no-install-recommends "${packages[@]}" 2> /dev/null \
+    | sed -n "s/^'\([^']*\)' \([^ ]*\) \([0-9]*\) \([^ ]*\).*/\3 \2 \4 \1/p" \
+    | while read -r size name hash address; do
+      line="$size $name $hash"
+      path="${address#mirror+file:/etc/apt/apt-mirrors.txt/}"
+      if [[ "$path" != "$address" && ${#mirrors[@]} -gt 0 ]]; then
+        for mirror in "${mirrors[@]}"; do
+          line+=" ${mirror%/}/$path"
+        done
+      else
+        line+=" $address"
+      fi
+      echo "$line"
+    done \
+    | sort -k 1,1nr > "$list" || true
+  rmdir "$empty" 2> /dev/null || true
+  total="$(wc -l < "$list")"
+  before="$(missing "$list")"
+  echo "$before of $total archives are not in $archives."
+  sudo mkdir -p "$archives/partial"
+  # One line, a size, a name, a hash and addresses, for each run of fetch.sh, and no
+  # run when there is no line. fetch.sh ends at the deadline by itself; the limit here
+  # is for what goes wrong in it.
+  sudo timeout "$((deadline - $(date +%s) + 60))" \
+    env APT_DEADLINE="$deadline" APT_MIN_SPEED="${APT_MIN_SPEED:-}" APT_SPEED_TIME="${APT_SPEED_TIME:-}" \
+    xargs -r -a "$list" -P "$parallel" -L 1 "$here/fetch.sh" "$archives" || true
+  after="$(missing "$list")"
+  echo "fetch.sh downloaded $((before - after)) archives."
+  if ((after > 0)); then
+    echo "::warning::$after archives are left for apt."
+  fi
+  rm -f "$list"
+}
+
+for ((attempt = 1; attempt <= 3; attempt++)); do
+  apt_get 2m update && break
+  if ((attempt == 3)); then
+    echo "::error::apt-get update failed in 3 attempts."
+    exit 1
+  fi
+  sleep 5
+done
+
+[[ "$parallel" -eq 0 ]] || prefetch
+
+# apt downloads what is still missing, and checks what it downloads, with what is
+# left of the time (a minute at least, which is enough to see that nothing is).
+left=$((deadline - $(date +%s)))
+((left > 60)) || left=60
+if ! apt_get "${left}s" install --download-only -y --no-install-recommends "${packages[@]}"; then
+  echo "::error::Could not download the packages (the limit is $seconds seconds); the mirrors are probably slow."
+  exit 1
+fi
+
+# Killing dpkg half way would leave packages unpacked but not configured, so
+# the installation has no time limit; it needs no network.
+apt_get 0 install -y --no-install-recommends "${packages[@]}"
+apt_get 0 autoclean
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index 774d19f..d527f8a 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -71,7 +71,10 @@ updates:
       nuget-packages:
         patterns: ["*"]
   - package-ecosystem: github-actions
-    directory: /
+    # The workflows, and the actions of this repository, which pin actions too.
+    directories:
+      - /
+      - /.github/actions/*
     schedule:
       interval: weekly
     groups:
diff --git a/.github/scripts/test_fetch.py b/.github/scripts/test_fetch.py
new file mode 100644
index 0000000..daf5ca0
--- /dev/null
+++ b/.github/scripts/test_fetch.py
@@ -0,0 +1,315 @@
+# Copyright 2026 Han Li and contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Tests of fetch.sh of the action install-linux-packages: python3 -m unittest discover -s .github/scripts
+
+Each mirror is an HTTP server of this process, which a test sets to be slow, to cut its
+connections, to have nothing, or to send the wrong file.
+"""
+
+import hashlib
+import os
+import random
+import re
+import socket
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+import unittest
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+
+FETCH = Path(__file__).resolve().parent.parent / "actions" / "install-linux-packages" / "fetch.sh"
+NAME = "pkg_1.0_amd64.deb"
+PATH = "/ubuntu/pool/main/p/pkg/" + NAME
+CONTENT = random.Random(7).randbytes(300_000)
+SIZE = len(CONTENT)
+SHA256 = "SHA256:" + hashlib.sha256(CONTENT).hexdigest()
+# The same size and another content, as a mirror that is wrong would send.
+WRONG = CONTENT[:1000] + bytes([CONTENT[1000] ^ 0xFF]) + CONTENT[1001:]
+
+
+class Handler(BaseHTTPRequestHandler):
+    protocol_version = "HTTP/1.1"
+
+    def log_message(self, *args):
+        pass
+
+    def do_GET(self):
+        settings = self.server.settings
+        self.server.requests.append(self.headers.get("Range"))
+        if settings.get("status") or self.path != PATH:
+            self.send_response(settings.get("status") or 404)
+            self.send_header("Content-Length", "0")
+            self.end_headers()
+            return
+        data = settings.get("content", CONTENT)
+        start = 0
+        requested = self.headers.get("Range")
+        if requested and not settings.get("ignore_range"):
+            start = int(re.match(r"bytes=(\d+)-", requested)[1])
+            if start >= len(data):
+                self.send_response(416)
+                self.send_header("Content-Range", f"bytes */{len(data)}")
+                self.send_header("Content-Length", "0")
+                self.end_headers()
+                return
+            self.send_response(206)
+            self.send_header("Content-Range", f"bytes {start}-{len(data) - 1}/{len(data)}")
+        else:
+            self.send_response(200)
+        body = data[start:]
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        rate = settings.get("rate")
+        cut = settings.get("cut_after")
+        chunk = max(1, rate // 20) if rate else 65536
+        sent = 0
+        try:
+            while sent < len(body):
+                if cut is not None and sent >= cut:
+                    self.close_connection = True
+                    self.request.shutdown(socket.SHUT_RDWR)
+                    return
+                part = body[sent : sent + chunk]
+                if cut is not None:
+                    part = part[: cut - sent]
+                self.wfile.write(part)
+                self.wfile.flush()
+                sent += len(part)
+                if rate:
+                    time.sleep(len(part) / rate)
+        except (BrokenPipeError, ConnectionResetError):
+            pass
+
+
+class Server(ThreadingHTTPServer):
+    daemon_threads = True
+
+    def handle_error(self, request, client_address):
+        # curl drops a connection that is too slow, and resets it.
+        pass
+
+
+class Mirror:
+    """A mirror that has the file; the Range header of each request is in requests."""
+
+    def __init__(self, **settings):
+        self.server = Server(("127.0.0.1", 0), Handler)
+        self.server.settings = settings
+        self.server.requests = []
+        self.requests = self.server.requests
+        threading.Thread(target=self.server.serve_forever, kwargs={"poll_interval": 0.01}, daemon=True).start()
+        self.url = f"http://127.0.0.1:{self.server.server_address[1]}{PATH}"
+
+    def close(self):
+        self.server.shutdown()
+        self.server.server_close()
+
+
+def refused_url() -> str:
+    """The address of a port where nothing listens."""
+    with socket.socket() as port:
+        port.bind(("127.0.0.1", 0))
+        return f"http://127.0.0.1:{port.getsockname()[1]}{PATH}"
+
+
+@unittest.skipUnless(sys.platform == "linux", "fetch.sh uses the tools of GNU")
+class FetchTest(unittest.TestCase):
+    def setUp(self):
+        temporary = tempfile.TemporaryDirectory()
+        self.addCleanup(temporary.cleanup)
+        self.directory = Path(temporary.name) / "archives"
+        (self.directory / "partial").mkdir(parents=True)
+        self.home = Path(temporary.name) / "home"
+        self.home.mkdir()
+
+    def mirror(self, **settings) -> Mirror:
+        mirror = Mirror(**settings)
+        self.addCleanup(mirror.close)
+        return mirror
+
+    def fetch(self, addresses, seconds=60, hash_=SHA256, size=SIZE, **environment):
+        """Runs fetch.sh, which drops a connection under 150000 bytes a second for a second."""
+        variables = {
+            key: value
+            for key, value in os.environ.items()
+            if not key.lower().endswith("_proxy") and key not in ("CURL_HOME", "XDG_CONFIG_HOME")
+        }
+        # Neither a proxy nor a .curlrc of the user changes where the requests go.
+        variables.update(HOME=str(self.home), NO_PROXY="127.0.0.1", APT_MIN_SPEED="150000", APT_SPEED_TIME="1")
+        variables.update(APT_DEADLINE=str(int(time.time()) + seconds))
+        variables.update(environment)
+        return subprocess.run(
+            ["bash", str(FETCH), str(self.directory), str(size), NAME, hash_, *addresses],
+            env=variables,
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=seconds + 30,
+        )
+
+    @property
+    def archive(self) -> Path:
+        return self.directory / NAME
+
+    @property
+    def partial(self) -> Path:
+        return self.directory / "partial" / NAME
+
+    def assertFetched(self, result):
+        self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
+        self.assertEqual(self.archive.read_bytes(), CONTENT)
+        self.assertFalse(self.partial.exists(), "nothing is left in partial/")
+
+    def test_downloads_the_archive_and_moves_it_out_of_partial(self):
+        mirror = self.mirror()
+        result = self.fetch([mirror.url])
+        self.assertFetched(result)
+        self.assertEqual(mirror.requests, [None])
+        self.assertEqual(result.stdout + result.stderr, "")
+
+    def test_continues_what_is_in_partial(self):
+        # The first version of the action wrote the file again from its start, and a file that
+        # takes longer than the time of one attempt never ended.
+        mirror = self.mirror()
+        self.partial.write_bytes(CONTENT[:100_000])
+        self.assertFetched(self.fetch([mirror.url]))
+        self.assertEqual(mirror.requests, ["bytes=100000-"])
+
+    def test_continues_after_a_connection_that_was_cut(self):
+        mirror = self.mirror(cut_after=100_000)
+        self.assertFetched(self.fetch([mirror.url]))
+        self.assertEqual(mirror.requests, [None, "bytes=100000-", "bytes=200000-"])
+
+    def test_a_partial_that_is_complete_needs_no_request(self):
+        mirror = self.mirror()
+        self.partial.write_bytes(CONTENT)
+        self.assertFetched(self.fetch([mirror.url]))
+        self.assertEqual(mirror.requests, [])
+
+    def test_a_partial_that_is_larger_than_the_file_starts_again(self):
+        mirror = self.mirror()
+        self.partial.write_bytes(CONTENT + b"more")
+        self.assertFetched(self.fetch([mirror.url]))
+        self.assertEqual(mirror.requests, [None])
+
+    def test_a_server_that_does_not_continue_sends_all_of_the_file(self):
+        mirror = self.mirror(ignore_range=True)
+        self.partial.write_bytes(CONTENT[:100_000])
+        self.assertFetched(self.fetch([mirror.url]))
+        self.assertEqual(mirror.requests, ["bytes=100000-", None])
+
+    def test_goes_to_the_next_mirror_when_one_has_not_the_file(self):
+        first, second = self.mirror(status=404), self.mirror()
+        self.assertFetched(self.fetch([first.url, second.url]))
+        self.assertEqual((len(first.requests), len(second.requests)), (1, 1))
+
+    def test_goes_to_the_next_mirror_when_one_does_not_answer(self):
+        second = self.mirror()
+        self.assertFetched(self.fetch([refused_url(), second.url]))
+
+    def test_goes_to_the_next_mirror_when_one_is_slow_and_continues_there(self):
+        first, second = self.mirror(rate=30_000), self.mirror()
+        result = self.fetch([first.url, second.url])
+        self.assertFetched(result)
+        self.assertEqual(len(first.requests), 1)
+        self.assertEqual(len(second.requests), 1)
+        self.assertRegex(second.requests[0], r"^bytes=[1-9]\d*-$", "the second mirror continued the file")
+        self.assertRegex(
+            result.stdout, rf"{NAME}: \d+ of {SIZE} bytes, \d+ bytes a second from 127\.0\.0\.1:\d+: curl: \(28\)"
+        )
+
+    def test_goes_on_with_the_best_mirror_when_every_one_is_slow(self):
+        # All below the minimum speed of 150000: a drops after a second at 30 KB/s, b after a second at
+        # 100 KB/s, and then b, the better, continues without being dropped.
+        a, b = self.mirror(rate=30_000), self.mirror(rate=100_000)
+        self.assertFetched(self.fetch([a.url, b.url]))
+        self.assertEqual(len(a.requests), 1, "the worse one is not asked again")
+        self.assertEqual(len(b.requests), 2)
+
+    def test_gives_up_when_no_mirror_has_the_file(self):
+        first, second = self.mirror(status=404), self.mirror(status=404)
+        result = self.fetch([first.url, second.url], seconds=120)
+        self.assertEqual(result.returncode, 1)
+        self.assertIn("no mirror sends it", result.stderr)
+        self.assertFalse(self.archive.exists())
+        self.assertEqual((len(first.requests), len(second.requests)), (3, 3), "three rounds")
+
+    def test_ends_at_the_deadline_and_keeps_what_came(self):
+        mirror = self.mirror(rate=50_000)
+        result = self.fetch([mirror.url], seconds=2, APT_MIN_SPEED="1000", APT_SPEED_TIME="10")
+        self.assertEqual(result.returncode, 1)
+        self.assertFalse(self.archive.exists())
+        self.assertTrue(0 < self.partial.stat().st_size < SIZE)
+
+    def test_checks_the_hash_before_the_archive_is_moved(self):
+        mirror = self.mirror(content=WRONG)
+        result = self.fetch([mirror.url])
+        self.assertEqual(result.returncode, 1)
+        self.assertIn("no mirror sends the right file", result.stderr)
+        self.assertFalse(self.archive.exists())
+        self.assertFalse(self.partial.exists())
+        self.assertEqual(len(mirror.requests), 3, "three downloads")
+
+    def test_tries_another_mirror_after_a_wrong_file(self):
+        wrong, right = self.mirror(content=WRONG), self.mirror()
+        result = self.fetch([wrong.url, right.url])
+        self.assertFetched(result)
+        self.assertEqual(right.requests, [None], "all of the file again, not what the wrong one sent")
+        self.assertIn(f"the hash is not {SHA256}", result.stdout)
+
+    def test_an_archive_in_the_directory_with_the_right_hash_is_kept(self):
+        mirror = self.mirror()
+        self.archive.write_bytes(CONTENT)
+        result = self.fetch([mirror.url])
+        self.assertFetched(result)
+        self.assertEqual(mirror.requests, [])
+        self.assertEqual(result.stdout, "")
+
+    def test_an_archive_in_the_directory_with_another_hash_is_replaced(self):
+        # apt takes it for a good one because of its size, and dpkg fails on it.
+        mirror = self.mirror()
+        self.archive.write_bytes(WRONG)
+        result = self.fetch([mirror.url])
+        self.assertFetched(result)
+        self.assertEqual(mirror.requests, [None])
+        self.assertIn("is not the one that apt expects; removed", result.stdout)
+
+    def test_an_archive_in_the_directory_with_another_size_is_replaced(self):
+        mirror = self.mirror()
+        self.archive.write_bytes(CONTENT[:1000])
+        self.assertFetched(self.fetch([mirror.url]))
+        self.assertEqual(mirror.requests, [None])
+
+    def test_checks_with_the_hash_type_that_apt_printed(self):
+        mirror = self.mirror()
+        self.assertFetched(self.fetch([mirror.url], hash_="MD5Sum:" + hashlib.md5(CONTENT).hexdigest()))
+
+    def test_a_hash_type_that_is_not_known_checks_nothing_and_fails(self):
+        mirror = self.mirror()
+        result = self.fetch([mirror.url], hash_="CRC32:abcdef")
+        self.assertEqual(result.returncode, 1)
+        self.assertFalse(self.archive.exists())
+
+    def test_needs_its_arguments(self):
+        result = subprocess.run(["bash", str(FETCH), str(self.directory)], check=False, capture_output=True, text=True)
+        self.assertEqual(result.returncode, 2)
+        self.assertIn("Usage: fetch.sh", result.stderr)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/.github/workflows/capacitor.yml b/.github/workflows/capacitor.yml
index a802fe0..f5ff8ee 100644
--- a/.github/workflows/capacitor.yml
+++ b/.github/workflows/capacitor.yml
@@ -76,10 +76,9 @@ jobs:
         working-directory: .
         run: grep -hE '^[A-Z0-9_]+=' web/versions.env capacitor/versions.env >> "$GITHUB_ENV"
       - name: Install the Linux packages
-        run: |
-          sudo apt-get update
-          # shellcheck disable=SC2086 # The list is meant to be split.
-          sudo apt-get install -y --no-install-recommends $LINUX_PACKAGES
+        uses: ./.github/actions/install-linux-packages
+        with:
+          packages: ${{ env.LINUX_PACKAGES }}
       - uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7.1.0
         with:
           node-version: ${{ env.NODE_VERSION }}
diff --git a/.github/workflows/compose.yml b/.github/workflows/compose.yml
index b676ec7..d09e55c 100644
--- a/.github/workflows/compose.yml
+++ b/.github/workflows/compose.yml
@@ -61,10 +61,9 @@ jobs:
       - name: Read the pinned versions
         run: grep -hE '^[A-Z0-9_]+=' versions.env >> "$GITHUB_ENV"
       - name: Install the Linux packages
-        run: |
-          sudo apt-get update
-          # shellcheck disable=SC2086 # The list is meant to be split.
-          sudo apt-get install -y --no-install-recommends $LINUX_PACKAGES
+        uses: ./.github/actions/install-linux-packages
+        with:
+          packages: ${{ env.LINUX_PACKAGES }}
       - name: Download the JDK
         run: |
           version="${JDK_RELEASE#jdk-}"
diff --git a/.github/workflows/dioxus.yml b/.github/workflows/dioxus.yml
index e1e5554..b4ee52c 100644
--- a/.github/workflows/dioxus.yml
+++ b/.github/workflows/dioxus.yml
@@ -65,10 +65,9 @@ jobs:
       - name: Read the pinned versions
         run: grep -hE '^[A-Z0-9_]+=' web/versions.env tauri/versions.env dioxus/versions.env >> "$GITHUB_ENV"
       - name: Install the Linux packages
-        run: |
-          sudo apt-get update
-          # shellcheck disable=SC2086 # The list is meant to be split.
-          sudo apt-get install -y --no-install-recommends $LINUX_PACKAGES
+        uses: ./.github/actions/install-linux-packages
+        with:
+          packages: ${{ env.LINUX_PACKAGES }}
       - uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7.1.0
         with:
           node-version: ${{ env.NODE_VERSION }}
diff --git a/.github/workflows/flet.yml b/.github/workflows/flet.yml
index 35c7686..3650bce 100644
--- a/.github/workflows/flet.yml
+++ b/.github/workflows/flet.yml
@@ -79,10 +79,9 @@ jobs:
           flutter-version: ${{ env.FLUTTER_VERSION }}
           cache: true
       - name: Install the Linux packages
-        run: |
-          sudo apt-get update
-          # shellcheck disable=SC2086 # The list is meant to be split.
-          sudo apt-get install -y --no-install-recommends $LINUX_PACKAGES
+        uses: ./.github/actions/install-linux-packages
+        with:
+          packages: ${{ env.LINUX_PACKAGES }}
       - name: Install the Python packages
         run: uv sync --frozen
       - name: Generate the inputs of the build
diff --git a/.github/workflows/flutter.yml b/.github/workflows/flutter.yml
index 64ff8f0..1b7e240 100644
--- a/.github/workflows/flutter.yml
+++ b/.github/workflows/flutter.yml
@@ -43,7 +43,9 @@ env:
   # Packages needed to build and run Flutter Linux desktop applications.
   LINUX_PACKAGES: >-
     clang cmake ninja-build pkg-config libgtk-3-dev liblzma-dev
-    patchelf lintian desktop-file-utils xvfb xauth dbus-daemon
+    xvfb xauth dbus-daemon
+  # And to build and validate the packages.
+  PACKAGING_PACKAGES: patchelf lintian desktop-file-utils
 
 defaults:
   run:
@@ -108,10 +110,9 @@ jobs:
     steps:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
       - name: Install Linux build dependencies
-        run: |
-          sudo apt-get update
-          # shellcheck disable=SC2086 # The list is meant to be split.
-          sudo apt-get install -y --no-install-recommends $LINUX_PACKAGES
+        uses: ./.github/actions/install-linux-packages
+        with:
+          packages: ${{ env.LINUX_PACKAGES }}
       - name: Read the pinned versions
         run: grep -E '^[A-Z0-9_]+=' versions.env >> "$GITHUB_ENV"
       - uses: subosito/flutter-action@1a449444c387b1966244ae4d4f8c696479add0b2 # v2.23.0
@@ -154,10 +155,9 @@ jobs:
     steps:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
       - name: Install Linux build dependencies
-        run: |
-          sudo apt-get update
-          # shellcheck disable=SC2086 # The list is meant to be split.
-          sudo apt-get install -y --no-install-recommends $LINUX_PACKAGES
+        uses: ./.github/actions/install-linux-packages
+        with:
+          packages: ${{ env.LINUX_PACKAGES }} ${{ env.PACKAGING_PACKAGES }}
       - name: Read the pinned versions
         run: grep -E '^[A-Z0-9_]+=' versions.env >> "$GITHUB_ENV"
       - uses: subosito/flutter-action@1a449444c387b1966244ae4d4f8c696479add0b2 # v2.23.0
diff --git a/.github/workflows/gio.yml b/.github/workflows/gio.yml
index 8307b4a..e331d8c 100644
--- a/.github/workflows/gio.yml
+++ b/.github/workflows/gio.yml
@@ -68,10 +68,9 @@ jobs:
       - name: Read the pinned versions
         run: grep -hE '^[A-Z0-9_]+=' web/versions.env gio/versions.env >> "$GITHUB_ENV"
       - name: Install the Linux packages
-        run: |
-          sudo apt-get update
-          # shellcheck disable=SC2086 # The list is meant to be split.
-          sudo apt-get install -y --no-install-recommends $LINUX_PACKAGES
+        uses: ./.github/actions/install-linux-packages
+        with:
+          packages: ${{ env.LINUX_PACKAGES }}
       - uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7.1.0
         with:
           node-version: ${{ env.NODE_VERSION }}
diff --git a/.github/workflows/mygo.yml b/.github/workflows/mygo.yml
index 0d1044b..95a0110 100644
--- a/.github/workflows/mygo.yml
+++ b/.github/workflows/mygo.yml
@@ -66,10 +66,9 @@ jobs:
       - name: Read the pinned versions
         run: grep -hE '^[A-Z0-9_]+=' web/versions.env mygo/versions.env >> "$GITHUB_ENV"
       - name: Install the Linux packages
-        run: |
-          sudo apt-get update
-          # shellcheck disable=SC2086 # The list is meant to be split.
-          sudo apt-get install -y --no-install-recommends $LINUX_PACKAGES
+        uses: ./.github/actions/install-linux-packages
+        with:
+          packages: ${{ env.LINUX_PACKAGES }}
       - uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7.1.0
         with:
           node-version: ${{ env.NODE_VERSION }}
diff --git a/.github/workflows/tauri.yml b/.github/workflows/tauri.yml
index 601ec06..ccc463e 100644
--- a/.github/workflows/tauri.yml
+++ b/.github/workflows/tauri.yml
@@ -60,10 +60,9 @@ jobs:
       - name: Read the pinned versions
         run: grep -hE '^[A-Z0-9_]+=' web/versions.env tauri/versions.env >> "$GITHUB_ENV"
       - name: Install the Linux packages
-        run: |
-          sudo apt-get update
-          # shellcheck disable=SC2086 # The list is meant to be split.
-          sudo apt-get install -y --no-install-recommends $LINUX_PACKAGES
+        uses: ./.github/actions/install-linux-packages
+        with:
+          packages: ${{ env.LINUX_PACKAGES }}
       - uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7.1.0
         with:
           node-version: ${{ env.NODE_VERSION }}
diff --git a/.github/workflows/uno.yml b/.github/workflows/uno.yml
index 551e471..5801aa0 100644
--- a/.github/workflows/uno.yml
+++ b/.github/workflows/uno.yml
@@ -69,10 +69,9 @@ jobs:
       - name: Read the pinned versions
         run: grep -hE '^[A-Z0-9_]+=' web/versions.env uno/versions.env >> "$GITHUB_ENV"
       - name: Install the Linux packages
-        run: |
-          sudo apt-get update
-          # shellcheck disable=SC2086 # The list is meant to be split.
-          sudo apt-get install -y --no-install-recommends $LINUX_PACKAGES
+        uses: ./.github/actions/install-linux-packages
+        with:
+          packages: ${{ env.LINUX_PACKAGES }}
       - uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7.1.0
         with:
           node-version: ${{ env.NODE_VERSION }}
diff --git a/.github/workflows/wails.yml b/.github/workflows/wails.yml
index 319a371..8ec9529 100644
--- a/.github/workflows/wails.yml
+++ b/.github/workflows/wails.yml
@@ -65,10 +65,9 @@ jobs:
       - name: Read the pinned versions
         run: grep -hE '^[A-Z0-9_]+=' web/versions.env wails/versions.env >> "$GITHUB_ENV"
       - name: Install the Linux packages
-        run: |
-          sudo apt-get update
-          # shellcheck disable=SC2086 # The list is meant to be split.
-          sudo apt-get install -y --no-install-recommends $LINUX_PACKAGES
+        uses: ./.github/actions/install-linux-packages
+        with:
+          packages: ${{ env.LINUX_PACKAGES }}
       - uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7.1.0
         with:
           node-version: ${{ env.NODE_VERSION }}
diff --git a/.github/workflows/web.yml b/.github/workflows/web.yml
index 6bc2dfd..9ec373a 100644
--- a/.github/workflows/web.yml
+++ b/.github/workflows/web.yml
@@ -60,9 +60,9 @@ jobs:
           cache: npm
           cache-dependency-path: web/package-lock.json
       - name: Install the font tools
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y --no-install-recommends fonttools python3-brotli
+        uses: ./.github/actions/install-linux-packages
+        with:
+          packages: fonttools python3-brotli
       - uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
         with:
           path: ~/.cache/material-symbols
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index f71bfe3..c99e857 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -72,6 +72,17 @@ all of them.
 Dependabot keeps the pub, npm, cargo, Go, Gradle and NuGet dependencies and the
 GitHub Actions up to date; actions are pinned to commit SHAs.
 
+The workflows install their Ubuntu packages with
+[`install-linux-packages`](.github/actions/install-linux-packages/action.yml), which
+keeps the downloaded archives in a cache (one for each list of packages and each
+week) and downloads what the cache lacks eight files at a time, continuing what was cut
+and trying the next mirror when one is slow, in 15 minutes at most. The Ubuntu mirror of
+the runners is slow for some of them at times: on 2026-10-23 a job got 40 KB/s for a
+connection while others downloaded 90 MB in seconds, and the 94 MB of Wails did not come
+in 30 minutes (a minute on a good day). apt does not check an archive that is in the
+directory, so the action checks every archive by its hash. A run that cannot finish
+saves what it downloaded, so that the next one gets further.
+
 A pull request that rebuilds an implementation gets a comment with the memory of all of
 them and the difference from `main`, which the next commit replaces instead of adding
 another one. A change that is more than the noise between CI runs is in bold; read
diff --git a/capacitor/README.md b/capacitor/README.md
index f474e27..ddd1251 100644
--- a/capacitor/README.md
+++ b/capacitor/README.md
@@ -154,12 +154,12 @@ of vfox+.
 
 Measured with `sandbox/sandbox.sh measure`: Ubuntu 26.04 in Docker, Xvfb with
 software rendering, a 1280 × 800 window, the Electron processes together (the
-browser, the zygotes, the network and renderer processes).
+browser, the zygotes and the renderer).
 
 | State                      |    RSS |    PSS |
 | -------------------------- | -----: | -----: |
-| Home page                  | 655 MB | 303 MB |
-| Versions of Node.js listed | 672 MB | 313 MB |
+| Home page                  | 468 MB | 267 MB |
+| Versions of Node.js listed | 487 MB | 281 MB |
 
 Electron brings its own Chromium, so nothing is shared with the libraries of
 the desktop; compare implementations measured the same way. `main.ts` calls
@@ -167,17 +167,20 @@ the desktop; compare implementations measured the same way. `main.ts` calls
 Chromium's GPU process maps Mesa's software OpenGL and its compiler, the same
 tax that the Gio and Flutter implementations pay and that the Uno and mygo
 implementations avoid, and the same build took 388 MB of PSS on the Home page
-instead of 303. On a machine with a GPU the numbers differ; measure there when
-it matters. Only the rows of the available versions that are in view are
-rendered ([TanStack Virtual](https://tanstack.com/virtual)).
+instead of 303. It also puts the GPU and the network service in the browser
+process (`in-process-gpu`, `NetworkServiceInProcess2`) and has V8 leave out its
+optimizing compiler (`--js-flags=--lite-mode`), for 267 MB of PSS in four
+processes instead of 305 in six. On a machine with a GPU the numbers differ;
+measure there when it matters. Only the rows of the available versions that
+are in view are rendered ([TanStack Virtual](https://tanstack.com/virtual)).
 
 A system WebView was tried instead of Electron for this same front end: the
 native side of [the Tauri implementation](../tauri/README.md), unchanged,
 hosting this implementation's own built page through a small
-`VfoxHostPlugin`. It measured worse, 422 MB of PSS on the Home page — a
-system WebView is not automatically cheaper than a bundled Chromium; compare
-[the whole table](../docs/memory.md), where Tauri, Dioxus and Wails all cost
-more than Capacitor even with their own accelerated compositing turned off.
+`VfoxHostPlugin`. It measured worse then, 422 MB of PSS on the Home page
+against 303 for Electron — before the settings that Tauri, Dioxus and Wails
+have now, which put them at 203 to 223 MB, below this implementation (see
+[the whole table](../docs/memory.md)). The shell was not measured again.
 Not pursued further.
 
 ## Differences from the Flutter implementation
diff --git a/capacitor/electron/main.ts b/capacitor/electron/main.ts
index 3ffdee4..1e86f8a 100644
--- a/capacitor/electron/main.ts
+++ b/capacitor/electron/main.ts
@@ -41,8 +41,14 @@ const RENDERER = join(__dirname, 'renderer');
 protocol.registerSchemesAsPrivileged([
   { scheme: SCHEME, privileges: { standard: true, secure: true, supportFetchAPI: true } },
 ]);
-// EXPERIMENT(memory): no GPU process, Skia rasterizes on the CPU instead.
+// No hardware acceleration: Skia rasterizes on the CPU, which keeps Mesa's software
+// OpenGL and its compiler out of the GPU process when there is no real GPU.
 app.disableHardwareAcceleration();
+// And fewer processes with memory of their own: the GPU and the network service run
+// in the browser process, and V8 leaves out its optimizing compiler.
+app.commandLine.appendSwitch('in-process-gpu');
+app.commandLine.appendSwitch('enable-features', 'NetworkServiceInProcess2');
+app.commandLine.appendSwitch('js-flags', '--lite-mode');
 // X11 takes WM_CLASS from the name, which the desktop entry names (StartupWMClass).
 app.setName(APP_ID);
 // Chromium keeps its profile apart from the settings of vfox+, among the caches.
diff --git a/compose/README.md b/compose/README.md
index bab66e0..d90c41e 100644
--- a/compose/README.md
+++ b/compose/README.md
@@ -114,9 +114,15 @@ software rendering, a 1280 × 800 window.
 
 | State | RSS | PSS |
 | --- | ---: | ---: |
-| Home page | 290 MB | 266 MB |
-| Versions of Node.js listed | 301 MB | 277 MB |
-
-The JVM runs with a heap of at most 256 MB and the serial collector; Skia
-draws the window itself, so there are no processes of a web view. Compare
-implementations measured the same way.
+| Home page | 135 MB | 129 MB |
+| Versions of Node.js listed | 158 MB | 152 MB |
+
+The JVM runs with a heap of at most 256 MB, the serial collector and only the
+first compiler of its JIT (`-XX:TieredStopAtLevel=1`: the optimizing one keeps
+tens of megabytes of its own), and Skia draws on the processor
+(`-Dskiko.renderApi=SOFTWARE`, in `build.gradle.kts`). Skiko draws with OpenGL
+by default, which maps Mesa's software OpenGL and its compiler when there is no
+real GPU: the same build took 253 MB of PSS on the Home page without the two
+settings, about half of the difference each, and used about twice the
+processor time. Skia draws the window itself, so there are no processes of a
+web view. Compare implementations measured the same way.
diff --git a/compose/build.gradle.kts b/compose/build.gradle.kts
index 7b1f44d..300ce25 100644
--- a/compose/build.gradle.kts
+++ b/compose/build.gradle.kts
@@ -218,8 +218,20 @@ compose.desktop {
     application {
         mainClass = "dev.vfox.plus.MainKt"
         // Lets Main.kt name the window class after the application ID; a small
-        // heap and the serial collector keep the memory of the JVM low.
-        jvmArgs += listOf("--add-opens=java.desktop/sun.awt.X11=ALL-UNNAMED", "-Xms32m", "-Xmx256m", "-XX:+UseSerialGC")
+        // heap and the serial collector keep the memory of the JVM low, and so
+        // do the first compiler of the JIT alone (the optimizing one keeps tens
+        // of megabytes of its own), and Skia on the processor: Skiko draws with
+        // OpenGL by default, which maps Mesa's software OpenGL and its compiler
+        // when there is no real GPU.
+        jvmArgs +=
+            listOf(
+                "--add-opens=java.desktop/sun.awt.X11=ALL-UNNAMED",
+                "-Xms32m",
+                "-Xmx256m",
+                "-XX:+UseSerialGC",
+                "-XX:TieredStopAtLevel=1",
+                "-Dskiko.renderApi=SOFTWARE",
+            )
         nativeDistributions {
             packageName = "vfox-plus"
             packageVersion = version.toString()
diff --git a/dioxus/README.md b/dioxus/README.md
index 3221646..33d53ac 100644
--- a/dioxus/README.md
+++ b/dioxus/README.md
@@ -122,15 +122,20 @@ processes together.
 
 | State | RSS | PSS |
 | --- | ---: | ---: |
-| Home page | 434 MB | 258 MB |
-| Versions of Node.js listed | 473 MB | 296 MB |
-
-`main.rs` sets `WEBKIT_DISABLE_COMPOSITING_MODE=1` before the webview starts,
-unless it is already set: without it, accelerated compositing maps Mesa's
-software OpenGL and its compiler, which the pages of vfox+ do not need, and
-the same build took 427 MB of PSS on the Home page instead of 258. Software
-rendering dominates what is left; compare implementations measured the same
-way. Only the rows of the available versions that are in view are rendered.
+| Home page | 385 MB | 203 MB |
+| Versions of Node.js listed | 402 MB | 220 MB |
+
+`main.rs` sets these variables before the webview starts, unless they are
+already set: `WEBKIT_DISABLE_COMPOSITING_MODE=1`, `WEBKIT_DISABLE_DMABUF_RENDERER=1`
+and `JSC_useJIT=false` for WebKitGTK and its JavaScript engine, and
+`GDK_GL=disable`, which keeps GDK from opening OpenGL for its windows on
+Wayland. Without them, accelerated compositing and the buffers that WebKit
+shares with the GPU map Mesa's software OpenGL and its compiler, which the
+pages of vfox+ do not need, and the JIT compiler of the web process keeps
+memory of its own: the same build took 261 MB of PSS on the Home page instead
+of 203 (and 427 MB in the snapshot before any of them was set). Compare
+implementations measured the same way. Only the rows of the available versions
+that are in view are rendered.
 
 Dioxus Native (the experimental [Blitz](https://github.com/DioxusLabs/blitz)
 renderer, WGPU, no system webview) was tried, to see whether dropping
diff --git a/dioxus/src/main.rs b/dioxus/src/main.rs
index f88ac9d..0012eaa 100644
--- a/dioxus/src/main.rs
+++ b/dioxus/src/main.rs
@@ -29,15 +29,24 @@ const APP_ID: &str = "dev.vfox.VfoxPlus";
 fn main() {
     glib::set_prgname(Some(APP_ID));
     glib::set_application_name("vfox+");
-    // Accelerated compositing maps Mesa's software OpenGL and its compiler when
-    // there is no real GPU; the pages of vfox+ do not need it. See
-    // docs/memory.md and the WebKitGTK documentation of this variable. Nothing
-    // else runs yet, so this is the one place an exception to
+    // Accelerated compositing, the buffers that WebKit shares with the GPU and
+    // the OpenGL of GDK on Wayland map Mesa's software OpenGL and its compiler
+    // when there is no real GPU, and the JIT compiler of the web process keeps
+    // memory of its own; the pages of vfox+ need none of it. See
+    // docs/memory.md and the variables of WebKitGTK and of its JavaScript
+    // engine. Nothing else runs yet, so this is the one place an exception to
     // `unsafe_code = "deny"` is justified.
-    if std::env::var_os("WEBKIT_DISABLE_COMPOSITING_MODE").is_none() {
-        #[allow(unsafe_code)]
-        unsafe {
-            std::env::set_var("WEBKIT_DISABLE_COMPOSITING_MODE", "1");
+    for (name, value) in [
+        ("WEBKIT_DISABLE_COMPOSITING_MODE", "1"),
+        ("WEBKIT_DISABLE_DMABUF_RENDERER", "1"),
+        ("JSC_useJIT", "false"),
+        ("GDK_GL", "disable"),
+    ] {
+        if std::env::var_os(name).is_none() {
+            #[allow(unsafe_code)]
+            unsafe {
+                std::env::set_var(name, value);
+            }
         }
     }
     // The first frame already has the colours of the stored settings; the
diff --git a/docs/memory.md b/docs/memory.md
index 7f0d975..c1f3cfd 100644
--- a/docs/memory.md
+++ b/docs/memory.md
@@ -15,39 +15,45 @@ memory columns, the PSS of the Home page, from the smallest to the largest (the
 is not in that order: see [Reading the numbers](#reading-the-numbers)); "Versions" is
 the SDKs page with the 872 available versions of Node.js listed.
 
-| Implementation                             | Technology                                      | Processes | Home PSS | Home RSS | Versions PSS | Versions RSS | The list adds (PSS) |
-| ------------------------------------------ | ----------------------------------------------- | --------: | -------: | -------: | -----------: | -----------: | ------------------: |
-| [mygo](../mygo/README.md#memory)           | mygo 0.5, Go, GTK 3 (purego), CPU renderer                |         1 |       41 |       54 |           47 |           60 |                  +6 |
-| [Uno](../uno/README.md#memory)             | Uno Platform 6, C# on .NET 10, Skia on the CPU, Native AOT |         1 |       99 |      106 |          116 |          123 |                 +17 |
-| [Gio](../gio/README.md#memory)             | Gio, Go, OpenGL ES through EGL                             |         1 |      215 |      240 |          228 |          253 |                 +13 |
-| [Dioxus](../dioxus/README.md#memory)       | Dioxus 0.7, Rust, WebKitGTK, compositing off               |         3 |      258 |      434 |          296 |          473 |                 +38 |
-| [Compose](../compose/README.md#memory)     | Compose Multiplatform, Kotlin on the JVM, Skia             |         1 |      266 |      290 |          277 |          301 |                 +11 |
-| [Tauri](../tauri/README.md#memory)         | Tauri 2, Rust, WebKitGTK 4.1 (GTK 3), compositing off      |         3 |      275 |      442 |          285 |          452 |                 +10 |
-| [Capacitor](../capacitor/README.md#memory) | Ionic Vue and Capacitor in Electron, no hardware GPU       |         6 |      303 |      655 |          313 |          672 |                 +10 |
-| [Flutter](../flutter/README.md#memory)     | Flutter 3.47, Dart, Impeller (OpenGL ES), GTK 3            |         2 |      329 |      369 |          345 |          384 |                 +16 |
-| [Flet](../flet/README.md#memory)           | Flet, Python 3.14 in a Flutter application                 |         2 |      346 |      378 |          383 |          415 |                 +37 |
-| [Wails](../wails/README.md#memory)         | Wails 3, Go, WebKitGTK 6.0 (GTK 4), compositing off        |         3 |      346 |      525 |          358 |          538 |                 +12 |
-
-- Turning off GPU-dependent rendering where the pages do not need it, and compiling
-  ahead of time where that lets trimming do a better job, closes most of the gap
-  between the four implementations that run in one process and draw themselves
-  (mygo, Uno, Gio, Compose, 41 to 266 MB of PSS on the Home page) and the four that
-  bring a web view or a browser: with WebKitGTK's accelerated compositing turned off,
-  Dioxus and Tauri are 258 and 275 MB, in three processes, both now cheaper than
-  Compose; Capacitor, with Electron's hardware acceleration off, is 303, in six
-  processes. mygo still uses under half of what Uno does, drawing on the processor
-  from a Go executable of 12 MB and loading GTK 3 from the system; Uno, compiled with
-  Native AOT instead of ReadyToRun, is a single piece of machine code with no separate
-  managed runtime, and keeping no XAML pages suits that well. Flutter and Flet, whose
-  client is a Flutter application too, follow at 329 and 346, each in two processes.
-  Wails, in the same three processes and with the same fix as Tauri and Dioxus, stays
-  at 346, tied with Flet: it links the heavier WebKitGTK 6.0 with GTK 4 instead of their
-  WebKitGTK 4.1 with GTK 3 (see below).
-- Showing the list of versions now adds 6 to 38 MB of PSS to every implementation; before
-  this page turned their accelerated compositing off, it added 73 to 84 MB to Tauri,
-  Dioxus and Wails, which show the list in WebKitGTK.
-- WebKitGTK 6.0 with GTK 4 (Wails) still needs 71 MB more than WebKitGTK 4.1 with GTK 3
-  (Tauri) for the same web front end, with accelerated compositing off on both.
+| Implementation                             | Technology                                                           | Processes | Home PSS | Home RSS | Versions PSS | Versions RSS | The list adds (PSS) |
+| ------------------------------------------ | -------------------------------------------------------------------- | --------: | -------: | -------: | -----------: | -----------: | ------------------: |
+| [mygo](../mygo/README.md#memory)           | mygo 0.5, Go, GTK 3 (purego), CPU renderer                           |         1 |       41 |       54 |           47 |           60 |                  +6 |
+| [Uno](../uno/README.md#memory)             | Uno Platform 6, C# on .NET 10, Skia on the CPU, Native AOT           |         1 |       98 |      106 |          113 |          122 |                 +15 |
+| [Compose](../compose/README.md#memory)     | Compose Multiplatform, Kotlin on the JVM, Skia on the CPU, C1 only   |         1 |      129 |      135 |          152 |          158 |                 +23 |
+| [Gio](../gio/README.md#memory)             | Gio, Go, OpenGL ES through EGL                                       |         1 |      165 |      202 |          171 |          208 |                  +6 |
+| [Flutter](../flutter/README.md#memory)     | Flutter 3.47, Dart, Skia on the CPU, GTK 3                           |         2 |      172 |      212 |          183 |          223 |                 +11 |
+| [Dioxus](../dioxus/README.md#memory)       | Dioxus 0.7, Rust, WebKitGTK, no compositing, DMA-BUF or JIT          |         3 |      203 |      385 |          220 |          402 |                 +17 |
+| [Tauri](../tauri/README.md#memory)         | Tauri 2, Rust, WebKitGTK 4.1 (GTK 3), no compositing, DMA-BUF or JIT |         3 |      208 |      382 |          220 |          394 |                 +12 |
+| [Flet](../flet/README.md#memory)           | Flet, Python 3.14 in a Flutter application, Skia on the CPU          |         2 |      216 |      257 |          224 |          266 |                  +8 |
+| [Wails](../wails/README.md#memory)         | Wails 3, Go, WebKitGTK 6.0 (GTK 4), as Tauri, GTK OpenGL off         |         3 |      223 |      408 |          237 |          431 |                 +14 |
+| [Capacitor](../capacitor/README.md#memory) | Ionic Vue and Capacitor in Electron, no GPU process, no V8 JIT       |         4 |      267 |      468 |          281 |          487 |                 +14 |
+
+- Without a GPU, what a toolkit does by default is to draw with the software OpenGL of
+  Mesa, and the memory of that and of its compiler (LLVM) is in the application. Taking it
+  out where the pages do not need it, compiling ahead of time and keeping the runtime
+  small moved the rows of this table more than anything else (see [No GPU](#reading-the-numbers)
+  below). mygo (41 MB of PSS on the Home page, in one process) draws on the processor from a
+  Go executable of 12 MB and loads GTK 3 from the system, and uses under half of what Uno
+  does: Uno (98) is compiled with Native AOT, a single piece of machine code with no
+  separate managed runtime, and keeping no XAML pages suits that well. Compose (129) draws
+  with Skia on the processor and runs the JVM with the first compiler of its JIT alone,
+  which keeps what the optimizing one needs out of the process. Gio (165) is the one that
+  still draws with OpenGL, and it has no renderer for the processor: the memory of Mesa is
+  most of its number, which also varies by 20 MB from one run to the next. Flutter and Flet
+  (172 and 216), whose client is a Flutter application too, draw with Skia on the processor
+  in two processes each; the engine still creates its OpenGL contexts at start-up, so
+  Mesa's compiler is in these numbers as well. The three implementations in WebKitGTK
+  (Dioxus 203, Tauri 208, Wails 223, in three processes) turn off the accelerated
+  compositing of WebKit, the buffers that it shares with the GPU and the JIT compiler of
+  the web process; Wails, with GTK 4 instead of GTK 3, keeps GTK from opening OpenGL
+  as well. Capacitor (267) is the largest: Electron's hardware acceleration is off, and the
+  GPU and the network service run in the main process, which leaves four processes.
+- Showing the list of versions now adds 6 to 23 MB of PSS to every implementation; before
+  the pages turned the accelerated compositing of WebKit off, it added 73 to 84 MB to
+  Tauri, Dioxus and Wails, which show the list in WebKitGTK.
+- WebKitGTK 6.0 with GTK 4 (Wails) needs 15 MB more than WebKitGTK 4.1 with GTK 3 (Tauri)
+  for the same web front end, with the settings of this table on both. It was 71 MB more
+  before Wails kept GTK 4 from opening OpenGL.
 
 ## How it is measured
 
@@ -78,9 +84,10 @@ nothing but Docker); the numbers above come from a WSL2 host with 16 logical CPU
   processes. PSS divides each shared page among the processes that map it, so the
   sum is what the application uses. Compare PSS.
 - **No GPU.** The virtual display has no GPU, so everything that draws with OpenGL
-  uses the software rasterizer of Mesa (llvmpipe), and its memory is in the numbers
-  (the Gio README says that it is most of what Gio uses). Uno was set to draw with Skia on the
-  processor, and the same build of it took 295 MB on the Home page with Mesa's
+  uses the software rasterizer of Mesa (llvmpipe), and its memory, with that of its
+  compiler (LLVM), is in the numbers (the Gio README says that it is most of what Gio
+  uses). The implementations that can do without it do. Uno was set to draw with Skia on
+  the processor, and the same build of it took 295 MB on the Home page with Mesa's
   software GL and 165 MB without it, with every other setting equal. mygo draws on the
   processor too, and the application has GDK leave OpenGL alone: the same build took
   about 78 MB when GDK opened its OpenGL connection, and about 43 MB when it did not.
@@ -89,9 +96,28 @@ nothing but Docker); the numbers above come from a WSL2 host with 16 logical CPU
   it off. Tauri, Dioxus and Wails set `WEBKIT_DISABLE_COMPOSITING_MODE=1` before their
   webview starts, which keeps WebKitGTK from entering accelerated compositing mode at
   all: the same builds took 419, 427 and 482 MB with it on, against 275, 258 and 346
-  with it off. On a machine with a GPU the numbers of the implementations that draw
-  with OpenGL, and perhaps the order, differ (Uno, mygo, Capacitor, Tauri, Dioxus and
-  Wails no longer depend on the GPU); measure there when it matters.
+  with it off. Later changes of the same kind, each measured against the build without
+  it on the day of this table: Compose with `-Dskiko.renderApi=SOFTWARE` (Skia on the
+  processor, not OpenGL) and `-XX:TieredStopAtLevel=1` (the JIT of the JVM without its
+  optimizing compiler), about 50 MB each, 253 to 129 MB together; Flutter with
+  `FLUTTER_LINUX_RENDERER=software` and Impeller turned off (the engine of 3.47 cannot
+  draw the text of Impeller to the canvas of the processor), 339 to 172 MB, and Flet,
+  whose Flutter 3.44 needs nothing but the variable, about 340 to 216 MB; Tauri and Dioxus with `WEBKIT_DISABLE_DMABUF_RENDERER=1` and
+  `JSC_useJIT=false` (WebKit's own buffers for a GPU, and the JIT of its JavaScript
+  engine), 262 to 208 and 261 to 203 MB; Wails with these and `GDK_DISABLE=gl,vulkan`
+  and `GSK_RENDERER=cairo` (GTK 4 opens OpenGL for its own window otherwise), 341 to 223
+  MB; Capacitor with `--in-process-gpu`, `NetworkServiceInProcess2` and
+  `--js-flags=--lite-mode`, 305 to 267 MB and from six processes to four; Gio with one
+  copy of the tables of its variable font instead of three and a garbage collector that
+  runs at 25 % growth, which takes the heap of Go from 57 to 20 MB, inside a number that
+  varies by 20 MB. On Wayland, GDK opens OpenGL for the windows of GTK 3, which Tauri,
+  Dioxus, Flutter and Flet prevent with `GDK_GL=disable` (Tauri on a headless sway: 242
+  MB without it, 207 with it); the numbers here are those of X11. Still created without
+  a GPU: the OpenGL contexts of the engine of Flutter, and those of the processes of
+  WebKit, which cannot start without EGL. On a machine with a GPU the numbers of the
+  implementations that draw with OpenGL, and perhaps the order, differ (Gio draws with
+  it; the others no longer depend on it, except for those contexts); measure there when it
+  matters.
 - **One measurement per row.** Nothing is averaged over runs, so small differences
   mean little; the implementations were measured one after another, with nothing else
   running. Flutter, which was measured six times on an earlier day, had 332 to 342 MB
diff --git a/flet/README.md b/flet/README.md
index 042cd27..75fe833 100644
--- a/flet/README.md
+++ b/flet/README.md
@@ -165,11 +165,19 @@ software rendering, a 1280 × 800 window.
 
 | State | RSS | PSS |
 | --- | ---: | ---: |
-| Home page | 378 MB | 346 MB |
-| Versions of Node.js listed | 415 MB | 383 MB |
+| Home page | 257 MB | 216 MB |
+| Versions of Node.js listed | 266 MB | 224 MB |
 
 The Flutter engine and the embedded interpreter share nothing with the
-libraries of the desktop; compare implementations measured the same way. Only
+libraries of the desktop; compare implementations measured the same way. The
+patch of the Flet build template (`tools/patch_build_template.py`, which also
+sets the size of the window) makes `main` set `FLUTTER_LINUX_RENDERER=software`
+and `GDK_GL=disable`: Skia draws on the processor instead of OpenGL, which maps
+Mesa's software OpenGL and its compiler when there is no real GPU, and the same
+build took about 340 MB of PSS on the Home page instead of 216. `flet build`
+keeps the project that it generated from the template, so a cache of an older
+build (the `vfox-plus-sandbox-flet-build` volume of the sandbox) has to be
+deleted for a changed template to take effect. Only
 the rows of the available versions that are in view are built
 ([`src/vfox_plus/ui/widgets/virtual_list.py`](src/vfox_plus/ui/widgets/virtual_list.py)).
 
diff --git a/flet/tools/patch_build_template.py b/flet/tools/patch_build_template.py
index 71824be..f27bf3f 100755
--- a/flet/tools/patch_build_template.py
+++ b/flet/tools/patch_build_template.py
@@ -13,8 +13,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""Patches the cached Flet build template so that the Linux window opens at
-the default size of the UI specification (1280 x 820).
+"""Patches the cached Flet build template of the Linux window: it opens at the
+default size of the UI specification (1280 x 820), and draws on the processor.
 
 `flet build` renders its Flutter shell from `flet-build-template.zip`, which
 it downloads once into `~/.flet/cache` (or `$FLET_CACHE_DIR`) and never
@@ -24,6 +24,12 @@
 of the tests. Patching the cached template sets the size before the first
 frame, with no resize at run time.
 
+The template also draws with OpenGL, which means Mesa's software rasterizer
+and its compiler when there is no real GPU, and takes as much memory as the
+rest of the application (docs/memory.md). The patched `main` has the engine
+draw with Skia on the processor (`FLUTTER_LINUX_RENDERER`) and GDK leave
+OpenGL alone, as the Flutter implementation does.
+
 Run it before `flet build` (the sandbox image and CI do):
 
     python3 tools/patch_build_template.py
@@ -45,8 +51,20 @@
 HEIGHT = 820
 """The default window size of the UI specification (`docs/ui-spec.md`)."""
 
-_MEMBER = "build/{{cookiecutter.out_dir}}/linux/my_application.cc"
-OLD = "gtk_window_set_default_size(window, 1280, 720);"
+_DIRECTORY = "build/{{cookiecutter.out_dir}}/linux/"
+SIZE = (
+    _DIRECTORY + "my_application.cc",
+    "gtk_window_set_default_size(window, 1280, 720);",
+    f"gtk_window_set_default_size(window, {WIDTH}, {HEIGHT});",
+)
+"""The window size, in the application of the GTK window."""
+
+_MAIN = "  g_autoptr(MyApplication) app = my_application_new();\n"
+_SETTINGS = '  g_setenv("FLUTTER_LINUX_RENDERER", "software", FALSE);\n  g_setenv("GDK_GL", "disable", FALSE);\n'
+RENDERER = (_DIRECTORY + "main.cc", _MAIN, _SETTINGS + _MAIN)
+"""The renderer, which `main` sets before GTK and the engine start."""
+
+PATCHES = (SIZE, RENDERER)
 
 
 def cache_path() -> pathlib.Path:
@@ -70,27 +88,34 @@ def main() -> None:
         print(f"Downloaded {path}")
     with zipfile.ZipFile(path) as archive:
         members = [(info, archive.read(info.filename)) for info in archive.infolist()]
-    copies = [data.decode() for info, data in members if info.filename == _MEMBER]
-    if not copies:
-        sys.exit(f"{_MEMBER} is not in {path}; the template of Flet {FLET_VERSION} changed.")
-    new = f"gtk_window_set_default_size(window, {WIDTH}, {HEIGHT});"
-    if all(OLD not in copy for copy in copies):
-        if not any(new in copy for copy in copies):
-            sys.exit(f"Cannot find {OLD!r} in {_MEMBER}; the template of Flet {FLET_VERSION} changed.")
-        print(f"{path} is already patched.")
+    pending = []
+    for member, old, new in PATCHES:
+        copies = [data.decode() for info, data in members if info.filename == member]
+        if not copies:
+            sys.exit(f"{member} is not in {path}; the template of Flet {FLET_VERSION} changed.")
+        if new in copies[0]:
+            print(f"{member} is already patched.")
+            continue
+        if old not in copies[0]:
+            sys.exit(f"Cannot find {old!r} in {member}; the template of Flet {FLET_VERSION} changed.")
+        pending.append((member, old, new, copies[0]))
+    if not pending:
         return
-    seen = False
+    replacements = {member: (old, new, copy) for member, old, new, copy in pending}
+    seen: set[str] = set()
     with zipfile.ZipFile(path.with_suffix(path.suffix + ".tmp"), "w", zipfile.ZIP_DEFLATED) as archive:
         for info, data in members:
-            if info.filename != _MEMBER:
+            if info.filename not in replacements:
                 archive.writestr(info, data)
-            elif not seen:
+            elif info.filename not in seen:
                 # There is only one copy after this rewrite, even if an
                 # earlier run of this script appended one already.
-                seen = True
-                archive.writestr(info, copies[0].replace(OLD, new))
+                seen.add(info.filename)
+                old, new, copy = replacements[info.filename]
+                archive.writestr(info, copy.replace(old, new))
     path.with_suffix(path.suffix + ".tmp").replace(path)
-    print(f"Patched {_MEMBER} in {path}")
+    for member in replacements:
+        print(f"Patched {member} in {path}")
 
 
 if __name__ == "__main__":
diff --git a/flutter/README.md b/flutter/README.md
index 83bf697..1fbc206 100644
--- a/flutter/README.md
+++ b/flutter/README.md
@@ -186,20 +186,32 @@ the steps and puts the result next to the other implementations:
 
 | Page | RSS | PSS |
 | --- | ---: | ---: |
-| Home | 369 MB | 329 MB |
-| Available versions of Node.js (872) | 384 MB | 345 MB |
+| Home | 212 MB | 172 MB |
+| Available versions of Node.js (872) | 223 MB | 183 MB |
 
 The application runs in two processes: the second, `glycin-svg`, is the helper that
-gdk-pixbuf starts to load the SVG icon of the window, and has 18 MB of the RSS. In
-six runs on an earlier day, with the sandbox images of that day, the PSS was 332 to
-342 MB on the Home page and 344 to 369 MB with the versions.
-
-Software rendering dominates these numbers; measure on the target hardware when
-comparing implementations, with
+gdk-pixbuf starts to load the SVG icon of the window, and has 18 MB of the RSS.
+
+`linux/runner/main.cc` sets `FLUTTER_LINUX_RENDERER=software` and `GDK_GL=disable`,
+and `my_application.cc` turns Impeller off (the engine of Flutter 3.47 stops with
+"Impeller DlText cannot be drawn to a Skia canvas" otherwise): Skia draws on the
+processor instead of OpenGL, which maps Mesa's software OpenGL and its compiler when
+there is no real GPU. The same build took 339 MB of PSS on the Home page without
+them, and 4 to 5 seconds of processor time until the page was shown, against 0.6.
+The engine creates its OpenGL contexts when it starts, whatever it draws with
+(`fl_opengl_manager_new` in `fl_engine.cc`), so Mesa's compiler is still part of the
+172 MB. Without the SVG icon of the window, which `set_window_icon` of
+`my_application.cc` loads through gdk-pixbuf and its helper, the application takes
+about 18 MB less, in one process; the desktop entry gives the window its icon when
+the package is installed. In six runs on an earlier day, with the sandbox images of
+that day and OpenGL, the PSS was 332 to 342 MB on the Home page and 344 to 369 MB
+with the versions.
+
+Measure on the target hardware when comparing implementations, with
 `awk '/^Rss:|^Pss:/' /proc/$(pidof vfox-plus)/smaps_rollup`.
 
 Before `measure` existed, the application was measured under WSLg, which renders in
 software with Mesa llvmpipe too, 10 seconds after start-up with a 1280 × 820
-window, for the process of the application alone: 336 MB of RSS and 320 MB of PSS on
-the Home page, against 254 MB and 247 MB for the counter app that `flutter create`
-makes, which is what Flutter itself needs.
+window, for the process of the application alone, with OpenGL: 336 MB of RSS and
+320 MB of PSS on the Home page, against 254 MB and 247 MB for the counter app that
+`flutter create` makes, which is what Flutter itself needed with OpenGL.
diff --git a/flutter/linux/runner/main.cc b/flutter/linux/runner/main.cc
index bd1317b..eda44ad 100644
--- a/flutter/linux/runner/main.cc
+++ b/flutter/linux/runner/main.cc
@@ -15,6 +15,12 @@
 #include "my_application.h"
 
 int main(int argc, char** argv) {
+  // Draw on the processor instead of OpenGL: without a real GPU, OpenGL means
+  // Mesa's software rasterizer and its compiler, which take as much memory as
+  // the rest of the application (see docs/memory.md). The engine draws with
+  // Skia then (my_application.cc), and GDK is told not to open OpenGL either.
+  g_setenv("FLUTTER_LINUX_RENDERER", "software", FALSE);
+  g_setenv("GDK_GL", "disable", FALSE);
   g_autoptr(MyApplication) app = my_application_new();
   return g_application_run(G_APPLICATION(app), argc, argv);
 }
diff --git a/flutter/linux/runner/my_application.cc b/flutter/linux/runner/my_application.cc
index d8d1f3c..6634841 100644
--- a/flutter/linux/runner/my_application.cc
+++ b/flutter/linux/runner/my_application.cc
@@ -91,6 +91,8 @@ static void my_application_activate(GApplication* application) {
   set_window_icon(window);
 
   g_autoptr(FlDartProject) project = fl_dart_project_new();
+  // Skia draws to the processor, which Impeller cannot do (see main.cc).
+  fl_dart_project_set_enable_impeller(project, FALSE);
   fl_dart_project_set_dart_entrypoint_arguments(
       project, self->dart_entrypoint_arguments);
 
diff --git a/gio/README.md b/gio/README.md
index 219eff5..84abbb6 100644
--- a/gio/README.md
+++ b/gio/README.md
@@ -207,8 +207,14 @@ one process.
 
 | State | RSS | PSS |
 | --- | ---: | ---: |
-| Home page | 240 MB | 215 MB |
-| Versions of Node.js listed | 253 MB | 228 MB |
+| Home page | 202 MB | 165 MB |
+| Versions of Node.js listed | 208 MB | 171 MB |
+
+Gio only draws with OpenGL, so Mesa's software OpenGL and its compiler are most
+of the number, and it varies by some 20 MB from one run to the next. The heap
+of Go is about 20 MB: `main.go` lets it grow by 25 % between collections, not
+100 %, and the three weights of the variable font of the interface share the
+tables of one parse ([`ui/kit/fonts.go`](ui/kit/fonts.go)); it was 57 MB.
 
 ## Limits
 
diff --git a/gio/main.go b/gio/main.go
index fb6d1a0..edf0c3c 100644
--- a/gio/main.go
+++ b/gio/main.go
@@ -18,6 +18,7 @@ package main
 import (
 	"log"
 	"os"
+	"runtime/debug"
 	"strings"
 
 	"github.com/version-fox/vfox-plus/gio/core"
@@ -27,6 +28,10 @@ import (
 )
 
 func main() {
+	// The live heap is 10 to 12 MB. The default of 100 % lets it double before
+	// the next collection, 25 % keeps what the application holds near what it
+	// needs, for a few collections more.
+	debug.SetGCPercent(25)
 	environment := make(map[string]string)
 	for _, entry := range os.Environ() {
 		if key, value, ok := strings.Cut(entry, "="); ok {
diff --git a/gio/ui/kit/fonts.go b/gio/ui/kit/fonts.go
index 450ef2a..ccbc64d 100644
--- a/gio/ui/kit/fonts.go
+++ b/gio/ui/kit/fonts.go
@@ -101,8 +101,9 @@ func (f faceOfVariation) Face() *fontapi.Face {
 }
 
 // parseFont parses a font of the data. Gio tells faces apart by their *Font,
-// so every variation of a variable font needs a Font of its own, and parses
-// the data again.
+// so every variation of a variable font needs a Font of its own: a copy of
+// the parsed one, which shares its tables (parsing the data again for each
+// would keep a copy of the tables for each in the memory).
 func parseFont(data []byte, index int) (*fontapi.Font, bool, error) {
 	if index > 0 || bytes.HasPrefix(data, []byte("ttcf")) {
 		loaders, err := opentype.NewLoaders(bytes.NewReader(data))
@@ -260,11 +261,15 @@ func loadFamily(faces *[]text.FontFace, regular fontSource, pattern string, type
 		regular.variable = variable
 	}
 	if regular.variable {
+		parsed, _, err := parseFont(data, regular.index)
+		if err != nil {
+			return false
+		}
 		for _, weight := range weights {
-			f, _, err := parseFont(data, regular.index)
-			if err != nil {
-				return false
-			}
+			// A Font of its own for every weight, which shares the tables of
+			// the one that was parsed.
+			clone := *parsed
+			f := &clone
 			*faces = append(*faces, text.FontFace{
 				Font: giofont.Font{Typeface: typeface, Weight: giofont.Weight(weight - 400)},
 				Face: faceOfVariation{font: f, variations: []fontapi.Variation{
diff --git a/tauri/README.md b/tauri/README.md
index 2967ad1..3856920 100644
--- a/tauri/README.md
+++ b/tauri/README.md
@@ -105,12 +105,16 @@ processes together.
 
 | State | RSS | PSS |
 | --- | ---: | ---: |
-| Home page | 442 MB | 275 MB |
-| Versions of Node.js listed | 452 MB | 285 MB |
-
-`lib.rs` sets `WEBKIT_DISABLE_COMPOSITING_MODE=1` before the webview starts,
-unless it is already set: without it, accelerated compositing maps Mesa's
-software OpenGL and its compiler, which the pages of vfox+ do not need, and
-the same build took 419 MB of PSS on the Home page instead of 275. Software
-rendering dominates what is left; compare implementations measured the same
-way.
+| Home page | 382 MB | 208 MB |
+| Versions of Node.js listed | 394 MB | 220 MB |
+
+`lib.rs` sets these variables before the webview starts, unless they are
+already set: `WEBKIT_DISABLE_COMPOSITING_MODE=1`, `WEBKIT_DISABLE_DMABUF_RENDERER=1`
+and `JSC_useJIT=false` for WebKitGTK and its JavaScript engine, and
+`GDK_GL=disable`, which keeps GDK from opening OpenGL for its windows on
+Wayland. Without them, accelerated compositing and the buffers that WebKit
+shares with the GPU map Mesa's software OpenGL and its compiler, which the
+pages of vfox+ do not need, and the JIT compiler of the web process keeps
+memory of its own: the same build took 262 MB of PSS on the Home page instead
+of 208 (and 419 MB in the snapshot before any of them was set). Compare
+implementations measured the same way.
diff --git a/tauri/src-tauri/src/lib.rs b/tauri/src-tauri/src/lib.rs
index 05a9bfc..d8400da 100644
--- a/tauri/src-tauri/src/lib.rs
+++ b/tauri/src-tauri/src/lib.rs
@@ -36,17 +36,27 @@ pub fn run() {
     // Before GTK starts: X11 takes WM_CLASS and Wayland the app ID from it.
     #[cfg(target_os = "linux")]
     glib::set_prgname(Some(APP_ID));
-    // Accelerated compositing maps Mesa's software OpenGL and its compiler when
-    // there is no real GPU; the pages of vfox+ do not need it. See
-    // docs/memory.md and the WebKitGTK documentation of this variable.
+    // Accelerated compositing, the buffers that WebKit shares with the GPU and
+    // the OpenGL of GDK on Wayland map Mesa's software OpenGL and its compiler
+    // when there is no real GPU, and the JIT compiler of the web process keeps
+    // memory of its own; the pages of vfox+ need none of it. See
+    // docs/memory.md and the variables of WebKitGTK and of its JavaScript
+    // engine.
     #[cfg(target_os = "linux")]
-    if std::env::var_os("WEBKIT_DISABLE_COMPOSITING_MODE").is_none() {
-        // Nothing else runs yet (no other thread can read the environment
-        // while this sets it), so this is the one place an exception to
-        // `unsafe_code = "deny"` is justified.
-        #[allow(unsafe_code)]
-        unsafe {
-            std::env::set_var("WEBKIT_DISABLE_COMPOSITING_MODE", "1");
+    for (name, value) in [
+        ("WEBKIT_DISABLE_COMPOSITING_MODE", "1"),
+        ("WEBKIT_DISABLE_DMABUF_RENDERER", "1"),
+        ("JSC_useJIT", "false"),
+        ("GDK_GL", "disable"),
+    ] {
+        if std::env::var_os(name).is_none() {
+            // Nothing else runs yet (no other thread can read the environment
+            // while this sets it), so this is the one place an exception to
+            // `unsafe_code = "deny"` is justified.
+            #[allow(unsafe_code)]
+            unsafe {
+                std::env::set_var(name, value);
+            }
         }
     }
     tauri::Builder::default()
diff --git a/uno/README.md b/uno/README.md
index f5606f4..a1ff991 100644
--- a/uno/README.md
+++ b/uno/README.md
@@ -232,8 +232,8 @@ Measured with `sandbox/sandbox.sh measure`: Ubuntu 26.04 in Docker, Xvfb, a
 
 | State | RSS | PSS |
 | --- | ---: | ---: |
-| Home page | 106 MB | 99 MB |
-| Versions of Node.js listed | 123 MB | 116 MB |
+| Home page | 106 MB | 98 MB |
+| Versions of Node.js listed | 122 MB | 113 MB |
 
 Skia draws with the processor. Uno would otherwise draw with OpenGL, and the
 graphics stack that this loads takes more memory than the application does:
@@ -241,7 +241,7 @@ with Mesa's software GL (LLVM) it was 295 MB on the Home page instead of 165 MB
 for the same build, with every other setting equal. An interface this size does
 not need the GPU, and the memory does not depend on the driver of the machine.
 Native AOT takes the Home page from 126 MB of PSS with the same build compiled
-ahead of time but still managed (ReadyToRun) to 99: no separate runtime loads
+ahead of time but still managed (ReadyToRun) to 98: no separate runtime loads
 reflection metadata or JITs anything at start-up, because there is no separate
 runtime, only the one piece of machine code Native AOT compiles the
 application and the parts of the .NET runtime it uses into together. This
diff --git a/wails/README.md b/wails/README.md
index 605bf12..0a02891 100644
--- a/wails/README.md
+++ b/wails/README.md
@@ -115,15 +115,19 @@ processes together.
 
 | State | RSS | PSS |
 | --- | ---: | ---: |
-| Home page | 525 MB | 346 MB |
-| Versions of Node.js listed | 538 MB | 358 MB |
-
-`main.go` sets `WEBKIT_DISABLE_COMPOSITING_MODE=1` before the application
-starts, unless it is already set: without it, accelerated compositing maps
-Mesa's software OpenGL and its compiler, which the pages of vfox+ do not
-need, and the same build took 482 MB of PSS on the Home page instead of 346.
-WebKitGTK 6.0 with GTK 4 still needs more than the WebKitGTK 4.1 with GTK 3 of
-the [Tauri implementation](../tauri/README.md#memory) for the same front end
-(275 MB, also with compositing off), by a larger margin than before this
-fix narrowed both. Software rendering dominates what is left; compare
-implementations measured the same way.
+| Home page | 408 MB | 223 MB |
+| Versions of Node.js listed | 431 MB | 237 MB |
+
+`main.go` sets these variables before the application starts, unless they are
+already set: `WEBKIT_DISABLE_COMPOSITING_MODE=1`, `WEBKIT_DISABLE_DMABUF_RENDERER=1`
+and `JSC_useJIT=false` for WebKitGTK and its JavaScript engine, and
+`GDK_DISABLE=gl,vulkan` and `GSK_RENDERER=cairo` for GTK 4. Without them,
+accelerated compositing, the buffers that WebKit shares with the GPU and the
+OpenGL renderer of GTK map Mesa's software OpenGL and its compiler, which the
+pages of vfox+ do not need, and the JIT compiler of the web process keeps
+memory of its own: the same build took 341 MB of PSS on the Home page instead
+of 223 (and 482 MB in the snapshot before any of them was set). WebKitGTK 6.0
+with GTK 4 still needs 15 MB more than the WebKitGTK 4.1 with GTK 3 of the
+[Tauri implementation](../tauri/README.md#memory) for the same front end (208
+MB, with the same settings but the ones of GTK); it was 71 MB more with the
+compositing alone off. Compare implementations measured the same way.
diff --git a/wails/main.go b/wails/main.go
index bc13e6c..3ed7781 100644
--- a/wails/main.go
+++ b/wails/main.go
@@ -92,11 +92,22 @@ func (desktop) Exit(code int) {
 }
 
 func main() {
-	// Accelerated compositing maps Mesa's software OpenGL and its compiler
-	// when there is no real GPU; the pages of vfox+ do not need it. See
-	// docs/memory.md and the WebKitGTK documentation of this variable.
-	if _, set := os.LookupEnv("WEBKIT_DISABLE_COMPOSITING_MODE"); !set {
-		_ = os.Setenv("WEBKIT_DISABLE_COMPOSITING_MODE", "1")
+	// Accelerated compositing, the OpenGL renderer of GTK and the buffers that
+	// WebKit shares with the GPU map Mesa's software OpenGL and its compiler
+	// when there is no real GPU, and the JIT compiler of the web process keeps
+	// memory of its own; the pages of vfox+ need none of it. The first three
+	// are variables of WebKitGTK and of its JavaScript engine, the others
+	// keep GTK 4 from opening OpenGL and Vulkan. See docs/memory.md.
+	for _, setting := range [...]struct{ name, value string }{
+		{"WEBKIT_DISABLE_COMPOSITING_MODE", "1"},
+		{"WEBKIT_DISABLE_DMABUF_RENDERER", "1"},
+		{"JSC_useJIT", "false"},
+		{"GDK_DISABLE", "gl,vulkan"},
+		{"GSK_RENDERER", "cairo"},
+	} {
+		if _, set := os.LookupEnv(setting.name); !set {
+			_ = os.Setenv(setting.name, setting.value)
+		}
 	}
 	frontend, err := fs.Sub(assets, "frontend/dist")
 	if err == nil {