Skip to content

LordOS — a free, fast and secure GNU/Linux distribution based on Debian, with its own desktop environment: display server and Wayland compositor in C, a React UI engine on QuickJS, and private native apps.

Frame pipeline and GPU drag off by default after the final Raspberry Pi 5 run: LORD_PIPELINE unset/0 off, 1 while frames are heavy, 2 always (+2-5 fps under load for 17-29 ms more pointer latency, auto engaged alone at 60 fps); LORD_GPU_DRAG=1 opt-in (self-test passes on V3D, 138 verified frames with 0 differences, no measurable gain); log lines and fpipe-test updated, goldens unchanged; every Pi-result marker filled with the run's numbers (both off: 59.9 fps alone, 30.5-31.1 under load; GPU time per frame 1.5 -> 14-16 ms under load, no throttling); CHANGELOG, BENCHMARK (final tables, first phases on a GPU, what was run, the Pi's cpu.ui/cpu.shape quick numbers, the rpi_volt alarm reading 0), GPU, WINDOWS (corner crops from the Pi monitor), ROADMAP, PAPER-VALIDATION, paper (en/es/pt), FAQ and A desktop of its own (en/es/pt)

Federico Pereira5a79238d49d6
diff --git a/CHANGELOG.md b/CHANGELOG.md
index a5fd008..8584466 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -16,8 +16,8 @@ of the matching [GitHub release](https://github.com/lordbasex/LordOS/releases),
`GPU.md`, `ROADMAP.md`, `PAPER-VALIDATION.md`, the paper (§3.2, §7.2, §7.4, §10.2; en, es, pt; `docs/PAPER.md`
regenerated), the FAQ and "A desktop of its own" (en, es, pt) now say that dragged windows' corners no longer turn
black and that LordBench's square and the Cooling fans turn (the docs audit's "still there, fixed in development"
- wording below is superseded), with the Pi 5 frame numbers measured so far and HTML comments starting with `PI-RESULT:`
- where the final Pi 5 run's numbers go, each next to a sentence that is true without them. The site's Markdown
+ wording below is superseded), with the Pi 5 frame numbers measured so far and HTML comments marking where the final Pi 5 run's numbers go, each
+ next to a sentence that is true without them (all filled after that run on 2026-10-29, the first entry under Changed). The site's Markdown
renderer (`web/lib/md.mjs`) now drops HTML comments, so a marker left behind is never published.
`THIRD_PARTY.md` lists the QuickJS `JS_GetMallocSize` patch as a table row.
- **Docs** (2026-10-28): `FANS.md` no longer says the Cooling fans turn in this build (the `transform` key the
@@ -157,7 +157,9 @@ of the matching [GitHub release](https://github.com/lordbasex/LordOS/releases),
and the temperature are the evidence instead, and the firmware's documented 80 °C limit now counts as
throttling (next item).
- **The Raspberry Pi firmware's throttling during a run** (`bench/lbcond.c`, `bench/lbrun.c`; `docs/BENCHMARK.md`,
- "The Raspberry Pi firmware's throttling"; tested on fake sysfs trees and VM 116, **not yet run on a real Pi**).
+ "The Raspberry Pi firmware's throttling"; tested on fake sysfs trees and VM 116, and on the Pi 5 on 2026-10-29:
+ `piFirmware` `{"flags": false, "voltageAlarm": true, "underVoltage": false, "tempLimit": false, "tempLimitC": 80}`,
+ the alarm 0 before and after the run with the official supply).
Checked in Raspberry Pi's `rpi-6.18.y` source, the kernel LordOS ships: `drivers/firmware/raspberrypi.c` has no
`get_throttled` file any more, and the `rpi_volt` hwmon (`drivers/hwmon/raspberrypi-hwmon.c`, a module in
`bcm2712_defconfig`) asks the firmware every 2 s with the sticky bits cleared and exposes only
@@ -261,11 +263,54 @@ of the matching [GitHub release](https://github.com/lordbasex/LordOS/releases),
`remote.sock`) wrote both phase objects in three runs (alone 601 frames, all on time; under load 720–721, 715–721 on time) and
the drag line. The
GPU fields (uploads, swap, fence) were 0 there: that path was built, not run.
- <!-- PI-RESULT: the first phases measured on a GPU: the Pi 5 run's frames.phases.load (paintMs, uploadMs, gpuMs,
- vblankWaitMs p50/p99; onTime / cpuLate / gpuLate) with the defaults, LORD_GPU_DRAG=0 and LORD_PIPELINE=0 -->
+ The first phases on a GPU came from the Raspberry Pi 5 with its monitor (V3D, 1920×1080, 2026-10-29; p50/p99 in ms).
+ With the frame pipeline and GPU drag off (the defaults now): alone `renderMs` 8.15/11.57 (`paintMs` 6.31/9.56,
+ `uploadMs` 1.41/1.72, 0.971 Mpx a frame) and `gpuMs` 1.51/1.57; under load `renderMs` 13.25/18.92 (paint 8.55/13.11,
+ upload 4.24/5.25) and `gpuMs` 14.49/19.00, and of 374 frames 39 on time, 14 CPU-late and 320 GPU-late. With the
+ pipeline off and GPU drag on: under load render 13.20/18.25, GPU 14.19/18.25, 23 on time, 15 CPU-late, 327 GPU-late of
+ 371. With the build's defaults then (the pipeline while frames are heavy, GPU drag on): under load render
+ 13.85/19.07, GPU 15.63/23.38, `heldMs` 18.27/31.60, 148 on time, 1 CPU-late, 285 GPU-late of 436. So under load the
+ frame is late on the GPU's side: its time per frame goes from about 1.5 ms alone to 14–16 ms.
### Changed
+- **The frame pipeline and GPU drag are off by default, after the final Raspberry Pi 5 run** (2026-10-29, in
+ development for 0.8.6; `docs/BENCHMARK.md`, "The drag frame's cost"; `docs/GPU.md`). The Pi 5 16 GB with its
+ 1920×1080 60 Hz HDMI monitor, the LordOS kernel 6.18.57-lordos.3, an autologin session and the arm64 build of this
+ branch; LordBench → Desktop impact, "under load" = all four cores busy at the lowest priority:
+
+ | Configuration | Runs | Alone fps | Pointer to screen p50 alone | Under load fps | Late under load | Pointer to screen p50 / p99 under load |
+ |---|---|---|---|---|---|---|
+ | Pipeline while frames are heavy, GPU drag on (the build's defaults then) | 2 | 60.0 | 42.1–42.5 ms | 33.0–36.2 | 65.8–81.6 % | 77.3–79.8 / 98.7–99.8 ms |
+ | `LORD_PIPELINE=0`, GPU drag on | 3 | 59.9 | 25.5–25.7 ms | 30.8–31.6 | 87.3–94.3 % | 48.8–49.0 / 66.1–79.4 ms |
+ | Both off (**the defaults now**) | 2 | 59.9 | 25.7–25.9 ms | 30.5–31.1 | 89.5–96.2 % | 48.5–49.0 / 66.3–80.6 ms |
+
+ - `LORD_PIPELINE` is now off unless set to `1` (while frames are heavy) or `2` (always): it gave 2–5 frames a second
+ under load but 17 ms more pointer latency alone and 29 ms more under load, and its auto mode engaged even alone at
+ 60 fps. The code stays; the session log says `lord-server: frame pipeline off (LORD_PIPELINE: unset or 0 off, 1
+ while frames are heavy, 2 always)`.
+ - GPU drag is now off unless `LORD_GPU_DRAG=1`, and its self-test runs only then: it is correct on V3D (its
+ self-test passes, 11,373,321 pixels in 341 ms; `LORD_GPU_VERIFY=1` compared 138 frames, all equal) but gave no
+ measurable gain (30.5–31.1 fps under load off, 30.8–31.6 on; it composed about one frame in five). The log says
+ `gpu: GPU drag off (LORD_GPU_DRAG=1 turns it on): the dragged window is composed by the CPU`.
+ - With both off the frames are the ones measured in the last row; the goldens are unchanged. So on the Pi 5 an
+ all-core load still takes the desktop from 60 to about 31 frames a second. What remains is the GPU's time per
+ frame: 1.5 ms alone, 14–16 ms under load (`frames.phases`: 320 of 374 frames GPU-late), and the upload of about
+ 1 Mpx a frame from 1.4 to about 4 ms, while `vcgencmd` every 2 s showed V3D at 0.86–1.15 GHz, the ARM cores at
+ 1.8–2.4 GHz, 36.7–47.2 °C and `get_throttled=0x0` throughout: no clock or thermal throttling. Most likely memory
+ contention with the load; not proven (no memory-bandwidth counter was read). Next: fewer pixels uploaded and
+ composed per frame (a buffer-age scissor, PBO uploads) and finding what slows V3D under CPU load (`ROADMAP.md`).
+ - In the same run: the firmware's power alarm (System Information's and LordBench's reader, `hw/rpifw.c`) is present
+ on the Pi 5's LordOS kernel and reads 0 with the official supply (`piFirmware`: `voltageAlarm` true, `underVoltage`
+ false; `in0_lcrit_alarm` 0 before and after); the dragged window's rounded corners are clean on the monitor (no
+ black squares, over a window and over the wallpaper; `docs/WINDOWS.md`); `lordos-sysreport bench --quick` (two
+ runs): `cpu.ui.1` 39.3–39.4 fps, `cpu.ui.n` 45.4 fps, `cpu.shape.1` 630–632 runs/s, `cpu.shape.n` 2,522–2,527
+ runs/s (`docs/BENCHMARK.md`).
+ - Checked on VM 116 with the new defaults: `make -j8` with no warnings; `make test`: 23 passed, 0 failed, 13
+ skipped; `engine-test`: 6,907 checks, 0 failures, `drag_golden_{cpu,gpu}.txt` unchanged; `fpipe-test`: 61 checks
+ (unset, `0`, an empty or any other value off, `1` while frames are heavy, `2` always; the auto mode's tests now
+ ask for `1`); `lordbench-test`: 1,217 ok.
+
- **The desktop under load, third step: a cheaper frame while a window is dragged** (in development for 0.8.6;
`docs/BENCHMARK.md`, "The drag frame's cost"; `docs/WINDOWS.md`; `docs/GPU.md`). Steps 0–11 (the next two
entries), GPU drag (the third) and the Fixed entries for the black corners, the rotated node's repaint and
@@ -278,10 +323,10 @@ of the matching [GitHub release](https://github.com/lordbasex/LordOS/releases),
30.1–30.3 fps (build p50 12.9 ms, 98.1–99.2 % late). Under load the build, the GPU's part and the flip still run
one after another and miss the 16.7 ms period, so the monitor shows every other vblank;
- with GPU drag on, the same build stalled (52 fps alone; its entry below);
- - the frame pipeline was built after these runs and has not run on a display yet. <!-- PI-RESULT: the final Pi 5
- run with the monitor: alone / under load fps, late %, build p50/p99 and pointer to screen with the defaults (GPU
- drag where its self-test passes, the pipeline while frames are heavy), with LORD_GPU_DRAG=0 and with
- LORD_PIPELINE=0 -->
+ - the frame pipeline was built after these runs; the final run with everything in this list (2026-10-29) has its own
+ entry at the top of Changed: with the frame pipeline and GPU drag off, the defaults now, alone 59.9 fps (build p50
+ 8.03–8.13 ms, p99 11.42–11.57 ms, 0.17 % late, pointer to screen p50 25.7–25.9 ms) and under load 30.5–31.1 fps
+ (build p50 13.15–13.25 ms, 89.5–96.2 % late, pointer to screen p50 48.5–49.0 ms, p99 66.3–80.6 ms).
- Checked on VM 116 at the frame pipeline's commit: `make -j8` and lord-server with `GPU=0` (no EGL, GBM or GLES
linked): no warnings; `make test`: 23 passed, 0 failed, 13 skipped; `engine-test`: 6,883 checks, 0 failures (the
2,417 golden frames per path, the `gpu-drag` path and the pipelined drag runs); `fpipe-test`: 39 checks;
@@ -476,8 +521,9 @@ of the matching [GitHub release](https://github.com/lordbasex/LordOS/releases),
(`glGetShaderPrecisionFormat`), then a self-test in `gpu_init` that draws every valid premultiplied (alpha,
colour ≤ alpha) over every destination value, and every source alpha over every destination alpha, into a
framebuffer (3,145,728 pixels in three 1024 × 1024 tiles), then a placement pass (below), and compares each
- pixel with `canvas_blit` on the CPU (NEON on the Pi). One differing pixel turns GPU drag off. `LORD_GPU_DRAG=0` turns it
- off. `LORD_GPU_VERIFY=N` paints W on the CPU too every N-th GPU drag frame
+ pixel with `canvas_blit` on the CPU (NEON on the Pi). One differing pixel turns GPU drag off. Since the Pi 5 run of
+ 2026-10-29 GPU drag is off by default and `LORD_GPU_DRAG=1` turns it on (the first entry under Changed); the
+ self-test runs only then. `LORD_GPU_VERIFY=N` paints W on the CPU too every N-th GPU drag frame
and compares it with the framebuffer read back (`gpu-verify: frame N W=wxh differ=K worst=D`).
- **`main.c`** keeps, per display, that the scene and the UI texture are stale in W (`gdrag_on`, `gdragw`): W joins the
next frame's damage; a frame with no UI damage (the cursor, an app's new frame) draws the window again from the
@@ -570,11 +616,15 @@ of the matching [GitHub release](https://github.com/lordbasex/LordOS/releases),
with the build before the uploads in slices and the phase timing; three runs): with GPU drag on, 52.2–52.9 fps
alone (build p99 21.3–21.7 ms, 13.5–15.0 % late) and 25.8–27.5 fps under load, against 59.8–60.0 and
30.1–30.3 fps with `LORD_GPU_DRAG=0` in the same build. It stalled; its cause was not measured (the phases did not
- exist yet). The next entry (the uploads in slices) and LordBench's phase timing (Added) were made for it. GPU
- drag stays on wherever its self-test passes until the final Pi run decides its default; its self-test and `LORD_GPU_VERIFY`
- have not been read on V3D yet. <!-- PI-RESULT: GPU drag on the Pi 5 with the final build: the `gpu: GPU drag
- on|off` line (self-test pixels and ms on V3D), LORD_GPU_VERIFY=1 differ= results, alone / under load fps with GPU
- drag on and with LORD_GPU_DRAG=0, frames.phases gpuDrag taken/refused and catchUpMpx; and the default chosen -->
+ exist yet). The next entry (the uploads in slices) and LordBench's phase timing (Added) were made for it.
+ - **On the Raspberry Pi 5 with the final build** (2026-10-29, with the uploads in slices): the self-test passes on
+ V3D (`gpu: GPU drag on: … self-test: 11373321 pixels, every valid premultiplied combination and a 4096x2048
+ placement pass, the same as the CPU's, 341 ms`), and with `LORD_GPU_VERIFY=1` the 138 GPU drag frames compared were
+ all `differ=0 worst=0`. It no longer stalls: with the frame pipeline off, 59.9 fps alone and 30.8–31.6 fps under
+ load (three runs) with GPU drag on, against 59.9 and 30.5–31.1 fps with it off (two runs). It composed only part of
+ the frames (138 of 601 alone, refused: `layer` 214, `after` 241, catching up 8; 80 of 436 under load). Correct,
+ but no measurable gain, so it is now **off by default** and `LORD_GPU_DRAG=1` turns it on (the first entry under
+ Changed).
- **GPU drag's textures catch up between frames instead of inside one** (0.8.6, in development; `docs/GPU.md`, "Uploads without a
stall"). A drag's start, or a copy of what is below built again whole, made the first GPU drag frame send the whole
copy (a screen, 8.3 MB at 1920 × 1080) and the layer; on V3D `glTexSubImage2D` converts to the GPU's tiled layout
@@ -601,8 +651,8 @@ of the matching [GitHub release](https://github.com/lordbasex/LordOS/releases),
7.5 ms (under 70 %) while the frame took about 13 ms, so the threads, which run at real-time priority, stayed off.
The pixels are the same (the pool's bands are exact). On VM 116 headless under load they were on for 0, 10 and 91
of 720–721 frames in three runs; the gain on the Pi is not measured yet.
-- **The frame pipeline: the next frame is painted while the flip is pending** (0.8.6, in development, not yet
- measured on the Pi; `docs/GPU.md`, "The frame pipeline"; `src/fpipe.c` and `main.c`). A frame was started only
+- **The frame pipeline: the next frame is painted while the flip is pending** (0.8.6, in development; measured on the
+ Pi 5 and **off by default** since then, `LORD_PIPELINE=1` or `2` turns it on; `docs/GPU.md`, "The frame pipeline"; `src/fpipe.c` and `main.c`). A frame was started only
after the previous flip completed, so input, JS, layout, paint, the upload, the GPU and the flip ran one after
another; on the Pi 5 under an all-core load that chain (about 13 ms of CPU, 3–5 ms more) passes the 16.7 ms
period, every frame waits for the second vblank and the monitor shows 30 frames a second, 98 % late.
@@ -615,8 +665,8 @@ of the matching [GitHub release](https://github.com/lordbasex/LordOS/releases),
flipped at once, so an idle desktop answers input as before.
- Only with one display that has real page flips, on the GPU and the CPU path; never without a monitor, with a
driver paced in software, or with several displays (each frame built and submitted at once there, as before).
- - `LORD_PIPELINE`, read once at startup and named in the session log: `0` off (the previous behaviour exactly), `2`
- always, unset (the default) on while frames are heavy: after 2 frames in a row whose CPU time passes 60 % of the
+ - `LORD_PIPELINE`, read once at startup and named in the session log: unset, `0` or anything else off (the previous
+ behaviour exactly; the default since the Pi 5 run), `2` always, `1` on while frames are heavy: after 2 frames in a row whose CPU time passes 60 % of the
period, off after 60 in a row under 40 % or at the first frame after more than half a second without one
(`FPIPE_IDLE_MS`; an idle desktop gives no frames to count, and without this the pipeline stayed on through it, so
the first input after it was shown a vblank later; that frame counts as the first of the two heavy ones that
@@ -664,10 +714,16 @@ of the matching [GitHub release](https://github.com/lordbasex/LordOS/releases),
`lordbench-test` (1,197 ok) checks a prepared frame's phases, its class, a late one and the pointer's latency
across the pipeline. LordBench's desktop test in an isolated headless session with `LORD_PIPELINE=1` and `=0`:
the same results (60 fps alone and under load, `prepared 0`: no flips without a monitor). VM 116 has no free
- DRM card (lord-sessiond holds its virtio-gpu card), so the pipeline itself has not run on a display yet.
- <!-- PI-RESULT: the frame pipeline on the Pi 5 with its monitor: Desktop impact alone and under load with
- LORD_PIPELINE unset and =0, two runs each (fps, late %, build p50/p99, pointer to screen p50/p99, prepared,
- heldMs p50/p99) -->
+ DRM card (lord-sessiond holds its virtio-gpu card), so the pipeline itself had not run on a display then.
+ - **On the Raspberry Pi 5 with its monitor** (2026-10-29, GPU drag on in both, two runs each): with the pipeline
+ while frames are heavy, alone 60.0 fps (build p50 8.26–8.31, p99 11.90–11.98 ms, 0 % late), pointer to screen p50
+ 42.1–42.5 ms; under load 33.0–36.2 fps (build p50 13.85–13.90, p99 19.07–19.36 ms, 65.8–81.6 % late), pointer to
+ screen p50 77.3–79.8, p99 98.7–99.8 ms; every frame was prepared ahead, alone too (held for the flip p50/p99 8.40/15.72
+ ms alone, 18.27/31.60 under load). With `LORD_PIPELINE=0`: alone 59.9 fps, pointer to screen p50 25.5–25.7 ms;
+ under load 30.8 fps (93.8–94.3 % late), pointer to screen p50 48.8–49.0, p99 66.1–66.3 ms. So it gave 2–5 frames a
+ second under load for 17 ms more pointer latency alone and 29 ms more under load, and its auto mode engaged even
+ alone at 60 fps (a frame of about 11.5 ms with the GPU's part passes 60 % of 16.7 ms): it is now **off by
+ default** (the first entry under Changed).
- **`js: unsupported style '<key>'` is logged once per key** (`style_warn` in `ui/js.c`), not on every
`setStyle` call: a style an animation sends every frame wrote a line to the session log every frame (as
`transform` did before LordBench's square and the fans moved to `rotate`). The first 64
@@ -677,7 +733,8 @@ of the matching [GitHub release](https://github.com/lordbasex/LordOS/releases),
### Fixed
- **System Information's Raspberry Pi power and throttling rows** (2026-10-29; `server/src/hw/rpifw.c`,
- `sysreport/sysreport.c`, `apps/sysinfo`; tested on fake sysfs trees and VM 116, **not yet on a real Pi**): the
+ `sysreport/sysreport.c`, `apps/sysinfo`; tested on fake sysfs trees and VM 116; the shared reader ran on the Pi 5 in
+ LordBench on 2026-10-29, the alarm present and reading 0, while System Information's rows were not looked at there): the
collector looked only for the firmware's `get_throttled` (`soc@107c000000:firmware` on the Pi 5), which the
`rpi-6.18.y` kernel LordOS ships doesn't have, so on a Pi 5 with LordOS the Power and Throttling rows were always
empty (and the Markdown report said nothing). System Information now reads the firmware the same way LordBench's
diff --git a/docs/BENCHMARK.md b/docs/BENCHMARK.md
index b5da0cc..9074c55 100644
--- a/docs/BENCHMARK.md
+++ b/docs/BENCHMARK.md
@@ -333,8 +333,8 @@ development package.
the scratch file is recorded (NVMe, SD/eMMC, SSD, HDD, USB, virtual, or RAM in the live session). Unit tests
on fake sysfs trees (`tests/lordbench_test.c`): an x86 laptop on battery, a Raspberry Pi 5 with the kernel
LordOS ships, a Pi known only from its device tree, and an older Pi kernel with `get_throttled`.
-- **The Raspberry Pi firmware's throttling** (0.8.6 in development, 2026-10-28; `bench/lbcond.c`, not yet run
- on a real Pi). On a Pi the firmware itself lowers the ARM clock on under-voltage, at its temperature limit
+- **The Raspberry Pi firmware's throttling** (0.8.6 in development, 2026-10-28; `bench/lbcond.c`; run on the Pi 5
+ on 2026-10-29, below). On a Pi the firmware itself lowers the ARM clock on under-voltage, at its temperature limit
or when the clock is capped, and cpufreq may not show it. What the kernel tells an unprivileged process,
checked in Raspberry Pi's `rpi-6.18.y` source (the branch `tools/rpi/build-kernel.sh` builds;
`bcm2712_defconfig` has `CONFIG_SENSORS_RASPBERRYPI_HWMON=m`):
@@ -374,7 +374,11 @@ development package.
"It reached 80 °C, where the board's firmware starts slowing the processor down", and "The board reports low
supply voltage" from `piFirmware` (older results keep using the end's bits), and Conditions gets a "Board
firmware" row listing what happened, or what was watched when nothing did. Machines that are not a Pi get no
- `piFirmware` and behave as before. Not verified on a real Pi yet: that the alarm reads `1` during an actual
+ `piFirmware` and behave as before. **On the Pi 5** (2026-10-29, the LordOS kernel 6.18.57-lordos.3, the official
+ supply, LordBench → Desktop impact): `piFirmware` was `{"flags": false, "voltageAlarm": true, "underVoltage": false,
+ "tempLimit": false, "tempLimitC": 80}`, `rpiUnderVoltageAlarm` 0 before and after and `in0_lcrit_alarm` 0: the
+ `rpi_volt` alarm is there and reads 0, and `get_throttled` is absent as the source says (`vcgencmd get_throttled`,
+ run by hand as root, said `0x0` throughout). Not verified yet: that the alarm reads `1` during an actual
under-voltage, and how fast the Pi 5 reaches 80 °C without a cooler in the peak tests.
The reader is shared (`hw/rpifw.c`, `rpifw_read`: lord-server, `lordos-sysreport` and the tests link it), and
@@ -387,7 +391,8 @@ development package.
only. The report's `raspberryPi` has `throttled` (the raw bits or `null`) and `underVoltageAlarm` (`true`,
`false` or `null`). Tested on fake sysfs trees (`tests/sysreport_test.c`: the LordOS kernel with the alarm clear,
set, malformed and missing; older Pi 4 and Pi 5 kernels with `get_throttled`; both; neither; a machine that isn't
- a Pi), not yet on a real Pi.
+ a Pi); on the Pi 5 the shared reader gave LordBench the values above, while System Information's rows themselves
+ were not looked at there.
- **Helper-sandbox self-test** (`sec.helper-sandbox`, repeated inside `lord-bench`, `sandbox_tries` in
`bench/lbmain.c`): right after `sandbox_apply_helper` and before any work, in every mode, `lord-bench` tries six
things that must fail: the Sandbox Probe's helper tries (`app/probe.c`) with its own versions of the data-folder
@@ -426,7 +431,8 @@ development package.
- **Reference machines** (`apps/sysinfo/references.js`): VM 116 and the Raspberry Pi 5 16 GB, each a Full run
copied from the `lordbench.json` it wrote (numbers below). A measurement added after a machine's run is listed in
its `notMeasured` until it is measured again: VM 116's layout, paint and shaping numbers come from a later Full
- run; the Pi 5 has none yet. The modest x86 PC is added when measured.
+ run; the Pi 5's were measured only in Quick runs from a terminal (below), so its reference still lists them as not
+ measured. The modest x86 PC is added when measured.
VM 116, Full with 30 s sustained, LordBench 1 (2026-10-27, 159 s): SHA-256 166 MB/s on one core and 984 MB/s on
eight; matrix product 3.3 and 19.9 GFLOP/s; xz 60 and 363 MB/s; QuickJS 57 and 336 runs/s; memory copy
@@ -461,6 +467,12 @@ throttling does not fire on the Pi; the `rpi_volt` under-voltage alarm is read);
temperature are the evidence that it did not throttle. (Since then the alarm is watched during the whole run and
the firmware's documented 80 °C limit counts as throttling on a Pi: "The Raspberry Pi firmware's throttling" above.)
+Raspberry Pi 5 16 GB, the interface workloads, two Quick runs from a terminal (`lordos-sysreport bench --quick
+--json`, the arm64 build of the `perf-frame` branch, 2026-10-29; 39 s each, 36.4 → 40.8 °C, the `ondemand` governor,
+4 threads): layout and paint 39.31–39.37 fps on one core and 45.38–45.41 fps with the paint threads; shaping
+630.0–632.3 runs/s on one core and 2,521.7–2,526.7 runs/s on four (4.0×). The Pi's paint threads gain about 15 %
+(VM 116: 8 %). These are not in `references.js` yet: a reference comes from a Full run.
+
Desktop impact:
| Machine | Phase | Frames shown | Build p50 | Build p99 | Late |
@@ -594,29 +606,49 @@ With GPU drag off the desktop is back at the refresh rate alone, and under the l
20 ms to 12.9 ms but every other frame is still late (30 fps): the chain of build, GPU and flip is still longer
than one period. With GPU drag on, that build stalled (52 fps alone, p99 about 21.5 ms): it ran before GPU drag's
textures caught up in slices between frames (`docs/GPU.md`, "Uploads without a stall") and before the frame phases
-below existed, so the cause was not measured. <!-- PI-RESULT: GPU drag on the Pi 5 with the final build: its
-self-test line from session.log (on/off, pixels, ms), LORD_GPU_VERIFY=1 differ= results, and a row "Frame-cost work,
-GPU drag on (slices)" with alone fps / p99 / late and under-load fps / p50 / late; then say whether it still stalls -->
-GPU drag's default is decided after that run: today it is on wherever its self-test passes, and
-`LORD_GPU_DRAG=0` turns it off.
+below existed, so the cause was not measured.
+
+**The final run** (2026-10-29, the arm64 build of the branch with everything in this section: the uploads in
+slices, the phase timing and the frame pipeline; the same Pi, monitor and test; build p50/p99 alone and under load
+are the compositor's own times):
-**The frame pipeline (in development, not yet measured on the Pi).** A frame that takes 13–16 ms to build cannot
+| Pi 5, monitor, final build | Runs | Alone: frames shown | Build p99 | Late | Under load: frames shown | Build p50 | Late |
+|---|---|---|---|---|---|---|---|
+| Pipeline and GPU drag off (**the defaults**) | 2 | 59.9 fps | 11.4–11.6 ms | 0.17 % | 30.5–31.1 fps | 13.2–13.3 ms | 89.5–96.2 % |
+| Pipeline off, GPU drag on | 3 | 59.9 fps | 11.4–11.7 ms | 0.17 % | 30.8–31.6 fps | 12.9–13.5 ms | 87.3–94.3 % |
+| Pipeline while frames are heavy, GPU drag on | 2 | 60.0 fps | 11.9–12.0 ms | 0 % | 33.0–36.2 fps | 13.9 ms | 65.8–81.6 % |
+| `LORD_GPU_VERIFY=1` (pipeline off, GPU drag on, every GPU drag frame read back) | 1 | 52.7 fps | 21.7 ms | 13.9 % | 26.6 fps | 14.6 ms | 97.2 % |
+
+Pointer to screen (LordBench's synthetic pointer, p50 alone; p50 / p99 under load): both off 25.7–25.9 ms and
+48.5–49.0 / 66.3–80.6 ms; GPU drag on 25.5–25.7 ms and 48.8–49.0 / 66.1–79.4 ms; the pipeline 42.1–42.5 ms and
+77.3–79.8 / 98.7–99.8 ms.
+
+GPU drag no longer stalls: its self-test passes on V3D (`gpu: GPU drag on: … self-test: 11373321 pixels, every valid
+premultiplied combination and a 4096x2048 placement pass, the same as the CPU's, 341 ms`), the 138 frames
+`LORD_GPU_VERIFY=1` compared were all `differ=0 worst=0` (the read-back is what slows that run), and it composed 138
+of 601 frames alone (refused: `layer` 214, `after` 241, `feed` 8) and 80 of 436 under load. Correct, but with no
+measurable gain (30.8–31.6 against 30.5–31.1 fps under load), so **GPU drag is off by default** since this run and
+`LORD_GPU_DRAG=1` turns it on (its self-test runs only then).
+
+**The frame pipeline (in development, measured on the Pi 5, off by default).** A frame that takes 13–16 ms to build cannot
fit with the GPU's part in a 16.7 ms period while the next frame is started only after the flip. Now, while a flip
is pending, the next frame's CPU part (input, JS frame callbacks, layout, paint into the scene) is done ahead, and at
-the flip only its upload, the GPU's draw and its flip are left (`docs/GPU.md`, "The frame pipeline"). On by
-default while frames are heavy (more than 60 % of the period, 2 frames in a row; off after 60 frames below 40 %, or
-at the first frame after more than half a second without one, so an idle desktop answers its next input without it),
-`LORD_PIPELINE=0` turns it off and `LORD_PIPELINE=2` keeps it on. Only with one display that has real page flips:
+the flip only its upload, the GPU's draw and its flip are left (`docs/GPU.md`, "The frame pipeline"). Off by
+default since the Pi 5 run; `LORD_PIPELINE=1` turns it on while frames are heavy (more than 60 % of the period, 2
+frames in a row; off after 60 frames below 40 %, or at the first frame after more than half a second without one, so
+an idle desktop answers its next input without it) and `LORD_PIPELINE=2` keeps it on. Only with one display that has real page flips:
without a monitor, with a driver paced in software or with several displays nothing changes. Expected on the Pi
under the load: the frames shown every vblank instead of every other one as long as the CPU part stays under one
period, with about the same pointer latency; that is a model (`build/fpipe-test` drives a display on a vblank
grid: 13 ms of CPU, 1 ms to submit and 3 ms of GPU give 299 flips in 600 periods without it and 598 with it, input
-to screen at most 33.3 and 36.0 ms), not a measurement. <!-- PI-RESULT: frame pipeline on the Pi 5 with its
-monitor: a table "Pi 5, monitor, pipeline" with LORD_PIPELINE unset vs LORD_PIPELINE=0, two runs each: alone and
-under-load frames shown, build p50/p99, late %, pointer to screen p50/p99, and frames.phases.load prepared /
-heldMs / onTime / cpuLate / gpuLate --> To measure: LordBench → Desktop impact twice with `LORD_PIPELINE` unset and
-twice with `LORD_PIPELINE=0` in the session's environment, comparing `desk.fps`, `desk.missed`, `desk.in50`/`in99`
-and `frames.phases.load` (`prepared`, `heldMs`, `onTime`).
+to screen at most 33.3 and 36.0 ms), not a measurement. **Measured on the Pi 5** (the table above, its auto
+mode then the default, with GPU drag on): under load 33.0–36.2 fps instead of 30.8–31.6, not 60, because the
+GPU's part, not the CPU's, is what passes the period there (below); every frame was prepared ahead, alone too
+(held for the flip p50/p99 8.40/15.72 ms alone, 18.27/31.60 ms under load; 148 of 436 frames on time under load, 1
+CPU-late, 285 GPU-late), since a frame of about 11.5 ms with the GPU's part passes 60 % of the period even at 60 fps;
+and the pointer reached the screen 17 ms later alone (42 against 25.5 ms) and 29 ms later under load (78 against 49
+ms). Two to five frames a second do not pay for that latency, so the pipeline is **off by default** and the code
+stays for `LORD_PIPELINE=1`/`2`.
#### Frame phases (0.8.6, in development)
@@ -676,14 +708,33 @@ run of the branch's lord-server in an isolated headless session (a test theme mo
`lord.wm.script` over 40 cards, CPU composition, one viewer on its `remote.sock`) wrote both objects: alone 601
frames, all on time, render 0.84/1.78 ms, paint 0.55/1.21 ms; under load 720–721 frames, 715–721 on time (three
runs). Those are a check that it works, not a measurement (a small scene, no GPU). The GPU fields were not
-exercised: VM 116 sessions are headless, so the fence, the uploads' times and GPU drag's counts have been built,
-not run. <!-- PI-RESULT: the Pi 5 run's frames.phases.load (p50/p99 of paintMs, uploadMs, gpuMs, vblankWaitMs and the
-onTime / cpuLate / gpuLate counts), with and without GPU drag and the pipeline, as the first measurement of the phases
-on a GPU -->
-
-**What to run on the Pi 5 next** (the package from this work installed, the monitor on, logged in):
-1. LordBench → Desktop impact, twice with the defaults (GPU drag where its self-test passes, the pipeline while frames
- are heavy), twice with `LORD_GPU_DRAG=0`, and twice with `LORD_PIPELINE=0`, in the session's environment.
+exercised there: VM 116 sessions are headless.
+
+**On the Pi 5 with its monitor** (2026-10-29, the first phases on a GPU; p50/p99 in ms):
+
+| Pi 5, final build | Phase | `renderMs` | `paintMs` | `uploadMs` | `gpuMs` | On time / CPU-late / GPU-late |
+|---|---|---|---|---|---|---|
+| Both off (the defaults) | alone | 8.15 / 11.57 | 6.31 / 9.56 | 1.41 / 1.72 | 1.51 / 1.57 | — |
+| | under load | 13.25 / 18.92 | 8.55 / 13.11 | 4.24 / 5.25 | 14.49 / 19.00 | 39 / 14 / 320 of 374 |
+| Pipeline off, GPU drag on | alone | 8.15 / 11.49 | 6.32 / 9.42 | 1.41 / 1.72 | 1.50 / 2.25 | — |
+| | under load | 13.20 / 18.25 | 8.59 / 12.91 | 3.96 / 4.87 | 14.19 / 18.25 | 23 / 15 / 327 of 371 |
+| Pipeline while heavy, GPU drag on | alone | 8.32 / 11.90 | 6.75 / 9.99 | 1.32 / 1.70 | 3.38 / 4.15 | — |
+| | under load | 13.85 / 19.07 | 9.03 / 13.55 | 3.93 / 4.78 | 15.63 / 23.38 | 148 / 1 / 285 of 436 |
+
+The UI texture's upload was 0.97 Mpx a frame with GPU drag off (0.84 with it on). Under load the frames are
+**GPU-late**: the build fits (about 13 ms), but the GPU's time per frame goes from about 1.5 ms alone to 14–16 ms,
+and the upload (a copy of about 1 Mpx) from 1.4 to about 4 ms. `vcgencmd`, every 2 s during a run, showed V3D at
+0.86–1.15 GHz (mostly 1.15), the ARM cores at 1.8–2.4 GHz, the core clock at 0.59–0.91 GHz, 36.7–47.2 °C and
+`get_throttled=0x0` throughout: no clock or thermal throttling. The likeliest cause is memory contention between the
+GPU and the four busy cores; that is not proven (no memory-bandwidth counter was read). The next step is fewer pixels
+uploaded and composed per frame (a buffer-age scissor, PBO uploads) and finding what slows V3D under CPU load
+(`ROADMAP.md`).
+
+**What was run on the Pi 5** (2026-10-29; the package from this work installed, the monitor on, an autologin
+session, the variables set in the session's environment; the results above):
+1. LordBench → Desktop impact, twice with the build's defaults then (GPU drag where its self-test passes, the
+ pipeline while frames are heavy), three times with `LORD_PIPELINE=0`, and twice with `LORD_PIPELINE=0
+ LORD_GPU_DRAG=0` (the defaults now).
2. From `~/.cache/lordos/session.log`: the `gpu: GPU drag on|off` line, the `lord-server: frame pipeline …` line, the
`lordbench: desktop … phases` lines and the `drag (scripted):` line, and from
`~/.local/state/lordos/lordbench-desktop.json` `frames.phases`.
@@ -693,7 +744,9 @@ on a GPU -->
With GPU drag, `gpuDrag.refused`/`gpuDrag.layer` say what keeps it off and `catchUpMpx` what the slices cost;
with the pipeline, `prepared` and `heldMs` say how many frames were painted ahead and how long they waited.
4. `LORD_GPU_VERIFY=1` once with GPU drag over a Desktop impact run: `gpu-verify: … differ=0` on every line.
-5. A real screenshot of a dragged window on the monitor (its rounded corners, `docs/WINDOWS.md`).
+5. A real screenshot of a dragged window on the monitor (its rounded corners, `docs/WINDOWS.md`): clean.
+6. `vcgencmd` every 2 s during one run (clocks, temperature, `get_throttled`), and `lordos-sysreport bench --quick
+ --json` twice (the interface workloads above).
Boot: the Pi 5 reaches the login screen on its monitor 5.99 s after the kernel starts (lord-sessiond's record;
systemd-analyze gives 2.1 s kernel + 4.2 s userspace). Boots where the monitor was connected late took 61 and
@@ -718,9 +771,9 @@ but the helper-sandbox self-test let a try through or one is missing (text outpu
code is 0 or 1 and the tries are in `sandboxTries`). On VM 116 a quick run took 46 s.
Not built yet: hardware video decoding (no test machine has VA-API, and the Pi 5's HEVC decoder needs FFmpeg's
-`v4l2request`); detecting the Pi's firmware throttling during a run on kernels that don't expose it; measuring the
-Pi 5 with the layout, paint and shaping workloads (its reference lists them as not measured); and the x86 PC
-reference.
+`v4l2request`); detecting the Pi's firmware throttling during a run on kernels that don't expose it; a Full run of
+the Pi 5 with the layout, paint and shaping workloads for its reference (two Quick runs measured them, above); and
+the x86 PC reference.
## 0.8.7 — Community hardware reports
diff --git a/docs/GPU.md b/docs/GPU.md
index a2c5fcd..f11c450 100644
--- a/docs/GPU.md
+++ b/docs/GPU.md
@@ -183,7 +183,8 @@ on the CPU inside the call, so the first GPU drag frame after such a change miss
frame has, so a pixel the slices missed shows): every frame matches, and it checks that no GPU drag frame has more than
`GDRAG_FEED_PX` of the copy left to send.
-**Off unless it proves itself:** `gpu_init` sets GPU drag up. It needs a fragment shader with at least 24-bit
+**Off by default** since the Raspberry Pi 5 run of 2026-10-29 (below): `LORD_GPU_DRAG=1` turns it on.
+**Then off unless it proves itself:** with it, `gpu_init` sets GPU drag up. It needs a fragment shader with at least 24-bit
`highp` floats (`glGetShaderPrecisionFormat`) and then a self-test, drawn into a framebuffer, read back
and compared with `canvas_blit` on the CPU (the NEON row on the Pi):
- arithmetic: every valid premultiplied (alpha, colour ≤ alpha) over every destination value (three of
@@ -198,11 +199,13 @@ and compared with `canvas_blit` on the CPU (the NEON row on the Pi):
One differing pixel turns it off. The outcome is kept per GL renderer and version across contexts, so a
GPU restart doesn't run it again. The log says `gpu: GPU drag on: … self-test: N pixels, every valid
premultiplied combination and a WxH placement pass, the same as the CPU's, T ms` or `gpu: GPU drag off: …`
-with the reason.
+with the reason; without `LORD_GPU_DRAG=1`, `gpu: GPU drag off (LORD_GPU_DRAG=1 turns it on): the dragged window is
+composed by the CPU`, and no self-test runs.
| Switch | Effect |
|---|---|
-| `LORD_GPU_DRAG=0` | GPU drag off: the dragged window is painted by the CPU as before |
+| unset, `LORD_GPU_DRAG=0` or anything but `1` | GPU drag off (the default): the dragged window is painted by the CPU as before |
+| `LORD_GPU_DRAG=1` | GPU drag on wherever its self-test passes |
| `LORD_GPU_VERIFY=N` | every N-th GPU drag frame W is also painted on the CPU (a walk clipped to W on a scratch canvas) and compared with the framebuffer read back: `gpu-verify: frame N W=wxh differ=K worst=D` |
The `drag: …` and `drag (scripted): …` lines end with `GPU drag: N of M frames (Q quads), strips … Mpx,
@@ -256,14 +259,24 @@ before the uploads in slices and the phase timing): with GPU drag on, 52.2–52.
13.5–15.0 % late) and 25.8–27.5 fps under load, against 59.8–60.0 and 30.1–30.3 fps with `LORD_GPU_DRAG=0` in the
same build (`docs/BENCHMARK.md`, "The drag frame's cost"). It stalled; the whole uploads inside a frame (V3D tiles
the texture on the CPU) are the likely cause and the reason for the slices above, but it was not measured, since
-the phases did not exist yet. <!-- PI-RESULT: GPU drag on the Pi 5 with the final build: the `gpu: GPU drag on|off`
-line (self-test pixels and ms on V3D), LORD_GPU_VERIFY=1 differ= over a Desktop impact run, alone / under load fps
-with GPU drag on and with LORD_GPU_DRAG=0, frames.phases gpuDrag taken/refused and catchUpMpx; then the default -->
-
-**Not checked yet:** on the Pi 5, its self-test, `LORD_GPU_VERIFY=1` over full LordBench desktop runs alone and under
-load, a run with the slices, a real screenshot and one run with `LORD_SW_CURSOR=1`. Until then no gain is claimed,
-and its default (on wherever the self-test passes) is decided after that run. Near the menu bar or the Dock the
-frame is still painted by the CPU.
+the phases did not exist yet.
+
+**The final run on the Pi 5** (2026-10-29, the build with the uploads in slices, the phase timing and the frame
+pipeline; LordBench's Desktop impact, with the pipeline off unless said; `docs/BENCHMARK.md`, "The drag frame's cost"):
+- The self-test passes on V3D: `gpu: GPU drag on: … self-test: 11373321 pixels, every valid premultiplied
+ combination and a 4096x2048 placement pass, the same as the CPU's, 341 ms`.
+- `LORD_GPU_VERIFY=1` over a whole Desktop impact run (alone and under load): 138 GPU drag frames compared, all
+ `differ=0 worst=0` (that run is slower, 52.7 and 26.6 fps, because of the read-back).
+- It no longer stalls: 59.9 fps alone and 30.8–31.6 fps under load with GPU drag on (three runs), 59.9 and
+ 30.5–31.1 fps with it off (two runs); pointer to screen p50 25.5–25.9 ms alone and 48.5–49.0 ms under load either
+ way. It composed 138 of 601 frames alone (refused: `layer` 214, `after` 241, catching up 8) and 80 of 436 under
+ load; the UI texture's upload fell from 0.97 to 0.84 Mpx a frame.
+- The rounded corners of the dragged window were clean in screenshots of the monitor during the scripted drag.
+
+Correct on V3D, but no measurable gain, so it is **off by default**, `LORD_GPU_DRAG=1` turns it on, and the self-test
+runs only then. What keeps the Pi at about 31 fps under load is the GPU's time per frame (1.5 ms alone, 14–16 ms
+under load, with no clock or thermal throttling; "The frame pipeline" below), which GPU drag does not reduce.
+**Not checked yet:** a run with `LORD_SW_CURSOR=1`. Near the menu bar or the Dock the frame is still painted by the CPU.
## The frame pipeline (0.8.6, in development)
@@ -291,8 +304,9 @@ virtual card: the wait there is the pacing slot, not the flip), and not with sev
layer and GPU drag state are shared between them; each frame is built and submitted at once there, as before). Both the
GPU and the CPU composition paths use it.
-**The switch** `LORD_PIPELINE`, read once at startup (the session log says which): `0` off (exactly the previous
-behaviour), `2` always, anything else (and unset, the default) *while frames are heavy*: on after 2 frames in a row
+**The switch** `LORD_PIPELINE`, read once at startup (the session log says which): unset, `0` or anything else off
+(exactly the previous behaviour; **the default** since the Pi 5 run below), `2` always, `1` *while frames are heavy*:
+on after 2 frames in a row
whose CPU time (JS frame callbacks, layout, paint, upload, swap and flip ioctl; for a prepared frame its prepare
plus its submission) is above 60 % of the refresh period, off after 60 frames in a row below 40 %, or at the first
frame after more than half a second without one (`FPIPE_IDLE_MS`: an idle desktop gives no frames to count, so
@@ -353,13 +367,28 @@ before the flips themselves came every other vblank) and the rate can double.
`heldMs` the time it waited for the flip, and the synthetic pointer's latency ends at its own presentation
(`lbf_painted`, `lbf_submitted`).
-**Not measured yet:** the Raspberry Pi 5 with its monitor, the machine this is for: LordBench's Desktop impact
-alone and under load with `LORD_PIPELINE` unset and with `LORD_PIPELINE=0`. VM 116 has no free DRM card (its
-virtio-gpu card belongs to lord-sessiond, and its flips would be paced in software anyway), so on it only the
-headless path ran (unchanged: `prepared 0`), with the unit tests and `engine-test`'s pipelined drag runs. No gain
-is claimed until the Pi run. <!-- PI-RESULT: the frame pipeline on the Pi 5 with its monitor: Desktop impact alone
-and under load with LORD_PIPELINE unset and =0 (fps, late %, pointer to screen p50/p99, prepared, heldMs p50/p99),
-and whether auto mode engaged (the `frame pipeline` lines with -d) -->
+VM 116 has no free DRM card (its virtio-gpu card belongs to lord-sessiond, and its flips would be paced in software
+anyway), so on it only the headless path ran (unchanged: `prepared 0`), with the unit tests and `engine-test`'s
+pipelined drag runs.
+
+**Measured on the Raspberry Pi 5 with its monitor** (2026-10-29, LordBench's Desktop impact, two runs each, GPU drag
+on in both; `docs/BENCHMARK.md`, "The drag frame's cost"):
+
+| Pi 5, monitor | Alone | Pointer to screen p50 alone | Under load | Late under load | Pointer to screen p50 / p99 under load |
+|---|---|---|---|---|---|
+| `LORD_PIPELINE` while frames are heavy (the default then) | 60.0 fps | 42.1–42.5 ms | 33.0–36.2 fps | 65.8–81.6 % | 77.3–79.8 / 98.7–99.8 ms |
+| `LORD_PIPELINE=0` | 59.9 fps | 25.5–25.7 ms | 30.8 fps | 93.8–94.3 % | 48.8–49.0 / 66.1–66.3 ms |
+
+The auto mode engaged even alone at 60 fps: a frame of about 11.5 ms with the GPU's part passes 60 % of the period,
+so every frame was prepared ahead (held for the flip p50/p99 8.40/15.72 ms alone, 18.27/31.60 ms under load). Under
+load it gained 2–5 frames a second, not the 60 the model expected, because the frames there are late on the GPU's
+side, not the CPU's: 285 of 436 GPU-late with it (148 on time, 1 CPU-late), 327 of 371 without it. The GPU's time per
+frame goes from about 1.5 ms alone to 14–16 ms under load, and the upload of about 1 Mpx from 1.4 to about 4 ms,
+while V3D stays at 0.86–1.15 GHz, the cores at 1.8–2.4 GHz, 36.7–47.2 °C and `get_throttled=0x0` (`vcgencmd` every
+2 s): no clock or thermal throttling, most likely memory contention with the busy cores (not proven: no
+memory-bandwidth counter was read). The pointer reached the screen 17 ms later alone and 29 ms later under load.
+So the pipeline is **off by default**; the code stays, with `LORD_PIPELINE=1` (while frames are heavy) and `2`
+(always) to turn it on.
## The CPU path on several threads (0.8.5)
@@ -525,9 +554,9 @@ virgl doesn't work without a render node on the host, and VM 116 was left with `
## Pending
-- GPU drag on the Raspberry Pi 5 (its self-test, `LORD_GPU_VERIFY`, a run with the uploads in slices) and its
- default; GPU drag also where the menu bar or the Dock overlap the window (step 12).
-- The frame pipeline measured on a real display (the Pi 5 with its monitor).
+- GPU drag also where the menu bar or the Dock overlap the window (step 12); it is off by default after the Pi 5 run.
+- Fewer pixels uploaded and composed per frame (a buffer-age scissor so the GPU composes only the damage, PBO uploads)
+ and finding what slows V3D under an all-core CPU load (14–16 ms of GPU a frame instead of 1.5).
- Test on real AMD (live ISO) and on Nvidia.
- UI blur that includes app content (GPU pass).
- Direct scanout of non-fullscreen windows (overlay planes).
diff --git a/docs/PAPER-VALIDATION.md b/docs/PAPER-VALIDATION.md
index 1bfa7da..d0a2b98 100644
--- a/docs/PAPER-VALIDATION.md
+++ b/docs/PAPER-VALIDATION.md
@@ -104,14 +104,14 @@ memory from a process's RSS (§7.1) and points to versioned results (§11.5, `do
| 7.2 | Video: lord-server 42 % → 13 %, fullscreen 92 % → 15 % of a core | Measured once | Measured |
| 7.1 | — | New in the 0.8.5-beta edition: the released package measured on a VMware VM updated from 0.8.4.1, whole system 592 MB used and the first frame 7.4 s after the kernel started (`results/0.8.5-beta/vmware-fusion`, `RESULTS.md`) | Measured, versioned results (§7.1) |
| 7.2 | — | New in 0.8.5: remote desktop CPU reference (`REMOTE.md`, "Measurements (0.8.5, CPU reference)") | Added in the 0.8.5 edition (§7.2) |
-| 7.2 | — | New, 0.8.6 in development: dragged windows' rounded corners no longer turn black (the drag layer's corner restore mixes both pixels alpha included); a drag frame repaints only what changed, pixel-identical except an approved 1-level change at rounded corners below the window; GPU drag composes the window with the CPU's exact arithmetic after a self-test (`WINDOWS.md`, `GPU.md`) | Test (`engine-test`: `test_drag_corners` against a full repaint on both paths, `test_drag_exact`'s 2,417 golden frame hashes per path, the `gpu-drag` path; `canvas-test`: GPU drag's arithmetic over all 8,421,376 valid combinations, x86_64 only) | Holds on VM 116; GPU drag's self-test and `LORD_GPU_VERIFY` not yet run on the Pi 5 (V3D) |
+| 7.2 | — | New, 0.8.6 in development: dragged windows' rounded corners no longer turn black (the drag layer's corner restore mixes both pixels alpha included); a drag frame repaints only what changed, pixel-identical except an approved 1-level change at rounded corners below the window; GPU drag composes the window with the CPU's exact arithmetic after a self-test (`WINDOWS.md`, `GPU.md`) | Test (`engine-test`: `test_drag_corners` against a full repaint on both paths, `test_drag_exact`'s 2,417 golden frame hashes per path, the `gpu-drag` path; `canvas-test`: GPU drag's arithmetic over all 8,421,376 valid combinations, x86_64 only) | Holds on VM 116; on the Pi 5 (V3D, 2026-10-29) GPU drag's self-test passes (11,373,321 pixels, 341 ms), `LORD_GPU_VERIFY=1` compared 138 frames with 0 differences, and screenshots of the monitor show clean corners while dragging; GPU drag is off by default (no measurable gain) |
| 7.3 | GPU benefits on real cards not measured | — | **Untested** |
| 7.4 | Pi 5: build 1 min 02 s, tests 23/0/0, NEON 2.0–2.3×, idle 36 MB, fan behaviour | Measured once on the Pi | Measured |
| 7.4 | — | New, 0.8.6 in development: with a 1920×1080 60 Hz monitor, login screen 5.99 s after the kernel starts; desktop 59.4 fps alone (p99 13.0 ms, 1 % late) and 24 fps under a low-priority all-core load (96.5 % late); 3 minutes sustained at 5.9 GFLOP/s, 55.6 °C; software video decoding per codec. LordBench on the Pi (`BENCHMARK.md`, "Built so far") | Measured with LordBench (one run each); the load result led to two fixes (compositor CPU weight: 31–33 % → 7–8 % late without the monitor; with the real-time priority, measured on the monitor: 24 → 28.9–30.5 fps, still 94–98 % late, the frame's build time under load still to explain) |
-| 7.4 | — | New, 0.8.6 in development: LordBench's square now turns; with it, the frame-cost work took the Pi 5 with its monitor from 53–58 to 59.8–60 fps alone and from 24–25 to 30 fps under load (GPU drag off); GPU drag on stalled at 52 fps alone; the frame pipeline is not measured (`BENCHMARK.md`, "The drag frame's cost") | Measured with LordBench on the Pi 5 (2–3 runs each, 2026-10-28; GPU drag's run predates its uploads in slices) | Measured; the final run with GPU drag and the pipeline is pending <!-- PI-RESULT: record the final Pi 5 run (defaults, LORD_GPU_DRAG=0, LORD_PIPELINE=0) and change the status --> |
+| 7.4 | — | New, 0.8.6 in development: LordBench's square now turns; with it, the frame-cost work took the Pi 5 with its monitor from 53–58 to 59.8–60 fps alone and from 24–25 to about 31 fps under load; the frame pipeline (+2–5 fps under load, 17–29 ms more pointer latency) and GPU drag (no measurable gain) were measured and are off by default; the remaining cost under load is the GPU's time per frame (1.5 → 14–16 ms, no clock or thermal throttling; memory contention likely, not proven) (`BENCHMARK.md`, "The drag frame's cost") | Measured with LordBench on the Pi 5 (2–3 runs each, 2026-10-28; final run 2026-10-29: both off 59.9 / 30.5–31.1 fps, pointer to screen p50 25.7–25.9 / 48.5–49.0 ms; GPU drag on 59.9 / 30.8–31.6; the pipeline 60.0 / 33.0–36.2 fps, pointer 42 / 78 ms; `vcgencmd` every 2 s) | Measured (2026-10-29) |
| 7.5 | No measurements on real PCs | — | **Untested** |
-| 7.5 | — | New, 0.8.6 in development: LordBench's interface workloads on VM 116 (layout and paint 37.0/39.9 fps, shaping 619/3,595 runs/s; compared only within the same LordOS version) and the helper-sandbox self-test (six tries, all refused on VM 116: seccomp `EPERM`, Landlock `EACCES`) (`BENCHMARK.md`, "Built so far") | Measured with LordBench (one Full and four Quick runs); not yet on the Pi 5 |
-| 7.5 | — | New, 0.8.6 in development: on a Raspberry Pi LordBench watches the firmware's under-voltage alarm (the only flag the LordOS kernel exposes), `get_throttled` on older kernels and 80 °C as the firmware's limit (a peak test stops as throttled); System Information's Raspberry Pi section reads the same through `hw/rpifw.c` and leaves out what the kernel doesn't show (`BENCHMARK.md`, "The Raspberry Pi firmware's throttling") | Tested on fake sysfs trees (`tests/lordbench_test.c`, `tests/sysreport_test.c`) on VM 116; not yet on a real Pi |
+| 7.5 | — | New, 0.8.6 in development: LordBench's interface workloads on VM 116 (layout and paint 37.0/39.9 fps, shaping 619/3,595 runs/s; compared only within the same LordOS version) and the helper-sandbox self-test (six tries, all refused on VM 116: seccomp `EPERM`, Landlock `EACCES`) (`BENCHMARK.md`, "Built so far") | Measured with LordBench (one Full and four Quick runs); on the Pi 5 two Quick runs from a terminal (2026-10-29): 39.3–39.4 / 45.4 fps, 630–632 / 2,522–2,527 runs/s, not yet in its reference (a Full run) |
+| 7.5 | — | New, 0.8.6 in development: on a Raspberry Pi LordBench watches the firmware's under-voltage alarm (the only flag the LordOS kernel exposes), `get_throttled` on older kernels and 80 °C as the firmware's limit (a peak test stops as throttled); System Information's Raspberry Pi section reads the same through `hw/rpifw.c` and leaves out what the kernel doesn't show (`BENCHMARK.md`, "The Raspberry Pi firmware's throttling") | Tested on fake sysfs trees (`tests/lordbench_test.c`, `tests/sysreport_test.c`) on VM 116; on the Pi 5 (2026-10-29) the `rpi_volt` alarm is present and reads 0 with the official supply (LordBench's `piFirmware`), `get_throttled` absent; an actual under-voltage not provoked |
## §10–§11 Limits and verification
diff --git a/docs/ROADMAP.md b/docs/ROADMAP.md
index a88f446..22d02f6 100644
--- a/docs/ROADMAP.md
+++ b/docs/ROADMAP.md
@@ -559,14 +559,18 @@ LordBench and a desktop that stays smooth under load. Each item is described in
pointer-to-screen latency, the N-boot test, `lordos-sysreport bench` and the Pi 5 reference.
- [x] LordOS's own interface work as workloads (`cpu.ui`, `cpu.shape`, fonts built into the helper) and the
helper-sandbox self-test inside `lord-bench` (2026-10-28).
-- [ ] The interface workloads measured on the Pi 5 (its reference lists them as not measured).
+- [ ] The interface workloads measured on the Pi 5 for its reference. *Two Quick runs from a terminal (2026-10-29):*
+ layout and paint 39.3–39.4 fps on one core, 45.4 fps with the paint threads; shaping 630–632 runs/s on one core,
+ 2,522–2,527 on four (`BENCHMARK.md`); the reference waits for a Full run.
- [ ] The x86 PC reference (a modest PC still to be chosen; may move to 0.8.7).
- [ ] Hardware video decoding (may move after 0.8.6).
-- [ ] Detecting the Pi 5 firmware's throttling. *Built, waiting for the check on a real Pi (2026-10-28/29):* the
+- [x] Detecting the Pi 5 firmware's throttling. *Built (2026-10-28/29), checked on the Pi 5 on 2026-10-29:* the
LordOS kernel (`rpi-6.18.y`) only exposes the firmware's under-voltage alarm (`rpi_volt`'s `in0_lcrit_alarm`, the
last 2 s), not its capped, throttled or soft-limit bits, so LordBench watches that alarm and `get_throttled` where
an older kernel has it, and counts 80 °C on a Pi as the firmware's limit (peak tests stop as throttled); System
- Information's Raspberry Pi rows read the same way through the shared `hw/rpifw.c`. Tested on fake sysfs trees only.
+ Information's Raspberry Pi rows read the same way through the shared `hw/rpifw.c`. Tested on fake sysfs trees, and
+ on the Pi 5: the `rpi_volt` alarm is present and reads 0 with the official supply (`piFirmware.voltageAlarm` true,
+ `underVoltage` false), `get_throttled` absent. An actual under-voltage was not provoked.
**The desktop under load** (`BENCHMARK.md`, "The desktop under load"; `GPU.md`). On the Pi 5 with its monitor the
desktop fell to 24 fps under an all-core load:
@@ -585,21 +589,26 @@ desktop fell to 24 fps under an all-core load:
GPU drag off: alone 53–58 → 59.8–60 fps, under load 24–25 → 30 fps; with GPU drag on it stalled (52 fps alone; that
run predates the slices and the phase timing).
- [x] Build the next frame while the previous flip is pending (the frame pipeline, `fpipe.c`, `LORD_PIPELINE`; `GPU.md`,
- "The frame pipeline"): on while frames are heavy, one display with real page flips, pixels unchanged
- (`fpipe-test`, `engine-test`'s pipelined drag runs). Estimated, not measured: 30 → 52–58 fps under load.
-- [ ] Measure the frame-cost work, GPU drag and the frame pipeline on the Pi 5 with its monitor and the phase timing
- (`BENCHMARK.md`, "What to run on the Pi 5 next"), with `LORD_GPU_VERIFY=1` once and a real screenshot.
- <!-- PI-RESULT: tick this item and add the measured numbers (alone / under load fps with the defaults, with
- LORD_GPU_DRAG=0 and with LORD_PIPELINE=0) -->
-- [ ] Decide GPU drag's default after that run: today it is on wherever its self-test passes (`LORD_GPU_DRAG=0` turns
- it off); off by default unless the new run shows no stalls.
+ "The frame pipeline"): one display with real page flips, pixels unchanged (`fpipe-test`, `engine-test`'s pipelined
+ drag runs). Estimated 30 → 52–58 fps under load; measured on the Pi 5, 30.8 → 33–36 fps for 17–29 ms more pointer
+ latency, so it is off by default (`LORD_PIPELINE=1` while frames are heavy, `2` always).
+- [x] Measure the frame-cost work, GPU drag and the frame pipeline on the Pi 5 with its monitor and the phase timing
+ (`BENCHMARK.md`, "What was run on the Pi 5"), with `LORD_GPU_VERIFY=1` once and a real screenshot (2026-10-29).
+ Both off (the defaults now): 59.9 fps alone, 30.5–31.1 fps under load, pointer to screen p50 25.7–25.9 / 48.5–49.0
+ ms; GPU drag on: 59.9 and 30.8–31.6 fps; the pipeline while frames are heavy: 60.0 and 33.0–36.2 fps, pointer
+ 42 / 78 ms. GPU drag's self-test passes on V3D and 138 verified frames had 0 differences; the dragged window's
+ corners are clean on the monitor. Under load 320 of 374 frames are GPU-late (the GPU's time per frame 1.5 → 14–16
+ ms, no clock or thermal throttling).
+- [x] Decide GPU drag's default after that run: **off** (`LORD_GPU_DRAG=1` turns it on): correct on V3D, no
+ measurable gain.
- [ ] Step 12: GPU drag for the whole drag, also where the Dock or the menu bar overlap the window.
-- [ ] Optional: cheaper uploads (pixel buffers or a linear canvas), scissoring the GPU composite to the damage,
- a 1000 Hz kernel tick for the Pi 5.
-- [ ] Merge `perf-frame`, with CHANGELOG, `BENCHMARK.md`, `GPU.md`, `WINDOWS.md`, `FANS.md`, the paper, the FAQ, the
- features page and `THIRD_PARTY.md` (the QuickJS `JS_GetMallocSize` patch); the docs are ready on the branch, with
- `PI-RESULT` comments where the Pi 5 run's numbers go. <!-- PI-RESULT: tick at the merge; fill every PI-RESULT
- marker (grep -rn PI-RESULT docs web/content CHANGELOG.md) -->
+- [ ] Next on the Pi 5 under load: fewer pixels uploaded and composed per frame (a buffer-age scissor so the GPU
+ composes only the damage, PBO uploads or a linear canvas) and finding what slows V3D under an all-core CPU load
+ (14–16 ms of GPU a frame instead of 1.5 with no clock change; memory contention is the likeliest cause, not proven:
+ read a memory-bandwidth counter). Optional: a 1000 Hz kernel tick for the Pi 5.
+- [x] Merge `perf-frame` (2026-10-29), with CHANGELOG, `BENCHMARK.md`, `GPU.md`, `WINDOWS.md`, `FANS.md`, the paper,
+ the FAQ, the features page and `THIRD_PARTY.md` (the QuickJS `JS_GetMallocSize` patch), with the final Pi 5 run's
+ numbers and the frame pipeline and GPU drag off by default.
**Release:**
- [ ] Re-measure the references after the release (results compare only within one LordOS version).
@@ -770,13 +779,14 @@ desktop fell to 24 fps under an all-core load:
code, one core and with the paint threads, and shaping fixed paragraphs in five scripts, with the fonts built
into the helper; VM 116: 37.0 and 39.9 fps, 619 and 3,595 runs/s), and the helper-sandbox self-test inside
`lord-bench` (six tries that must fail, checked by the Stability verdict and `lordos-sysreport bench`). Left:
- hardware video decoding, the x86 PC reference, measuring the Pi 5 with the interface workloads (its reference
- lists them as not measured), checking the Pi 5 firmware's throttling detection on a real Pi (built on fake sysfs
- trees: the LordOS kernel only exposes the under-voltage alarm, so 80 °C counts as the firmware's limit), and the rest of what it found on the Pi 5 (the desktop fell to 24 fps under load;
+ hardware video decoding, the x86 PC reference, a Full run of the Pi 5 with the interface workloads for its reference
+ (two Quick runs measured them on 2026-10-29), and the rest of what it found on the Pi 5 (the desktop fell to 24 fps under load;
the compositor's CPU weight and its real-time priority fix it on VM 116; on the Pi 5 with its monitor they take it
to 29–30 fps; the frame-cost work cuts a drag frame's build under load to 12.9 ms and keeps 60 fps alone, but
- under load the build, the GPU and the flip still miss the refresh, at 30 fps, and the frame pipeline built for
- that is not yet measured: `BENCHMARK.md` "The desktop under load" and "The drag frame's cost").
+ under load the frames still miss the refresh, at about 31 fps, now on the GPU's side (its time per frame 1.5 → 14–16
+ ms under load, no throttling); the frame pipeline and GPU drag, measured on 2026-10-29, gave too little and are off
+ by default: `BENCHMARK.md` "The desktop under load" and "The drag frame's cost"). The firmware throttling
+ detection was checked on the Pi 5 (the under-voltage alarm present, reading 0).
- [ ] **Community hardware reports (0.8.7)** — `BENCHMARK.md`. Share on GitHub with the
`hardware-report` template (the user submits it, LordOS sends nothing), schema validation and
labels in a workflow, and a tested-hardware catalogue on lordos.org that the Compatibility panel
diff --git a/docs/WINDOWS.md b/docs/WINDOWS.md
index f78d5f2..207f2c9 100644
--- a/docs/WINDOWS.md
+++ b/docs/WINDOWS.md
@@ -153,7 +153,8 @@ wm.beginResize(id, edges) // edges as in xdg_toplevel.resize: 1 top, 2 botto
and the copy (two textures uploaded only where they changed) with `blit_row`'s own arithmetic, so
the pixels are the same. Not when an ancestor paints over the window, an app window is under it,
a node painted after it (the menu bar, the Dock) meets the box, or the layer has an app window or
- would be painted whole; then the frame is painted as before. `LORD_GPU_DRAG=0` turns it off,
+ would be painted whole; then the frame is painted as before. Off by default since the Pi 5 run
+ of 2026-10-29 (right on V3D, no measurable gain there); `LORD_GPU_DRAG=1` turns it on,
`LORD_GPU_VERIFY=N` compares it with the CPU every N-th frame. `engine-test`'s `gpu-drag` path checks it
against the GPU path's golden hashes.
- **There's no layer** if there is a backdrop blur inside (`backdropFilter`), or a video on the GPU
@@ -208,8 +209,16 @@ wm.beginResize(id, edges) // edges as in xdg_toplevel.resize: 1 top, 2 botto
- **`test_drag_corners`** checks the corners of a dragged rounded window against a full repaint (above).
- **On the Raspberry Pi 5** with its monitor, LordBench's desktop test (its square turning) went from 53–58
to 59.8–60 fps alone and from 24–25 to 30 fps under load with this work and GPU drag off
- (`docs/BENCHMARK.md`, "The drag frame's cost"). <!-- PI-RESULT: the final Pi 5 run (defaults, LORD_GPU_DRAG=0,
- LORD_PIPELINE=0) and a real screenshot of a dragged window's corners on the monitor -->
+ (`docs/BENCHMARK.md`, "The drag frame's cost"). The final run (2026-10-29, GPU drag and the frame pipeline off,
+ the defaults now): 59.9 fps alone and 30.5–31.1 fps under load, the pointer on screen 25.7–25.9 ms after it moved
+ alone (p50) and 48.5–49.0 ms under load; with GPU drag on 30.8–31.6 fps, with the frame pipeline 33.0–36.2 fps
+ but 17–29 ms more pointer latency, so both stay off. Under load the frames are late on the GPU's side
+ (`docs/GPU.md`, "The frame pipeline"). Screenshots of the monitor during the scripted drag (crops of the dragged
+ window's lower corners, over another window and over the wallpaper): the rounded corners are clean, no black
+ squares.
+
+ ![A dragged window's lower-left corner over another window, Raspberry Pi 5 monitor](drag-corner-pi5-over-window.png)
+ ![A dragged window's lower-right corner over the wallpaper, Raspberry Pi 5 monitor](drag-corner-pi5-over-wallpaper.png)
- **`LORD_PAINT_VERIFY=N`** in lord-server's environment repaints the whole tree every N-th frame of a
display into a scratch canvas, without the layer, and writes to stderr how many pixels differ from
the frame. Use N > 1 to check the partial repaints of the layer: the check repaint also notes where
diff --git a/docs/drag-corner-pi5-over-wallpaper.png b/docs/drag-corner-pi5-over-wallpaper.png
new file mode 100644
index 0000000..701b7a4
Binary files /dev/null and b/docs/drag-corner-pi5-over-wallpaper.png differ
diff --git a/docs/drag-corner-pi5-over-window.png b/docs/drag-corner-pi5-over-window.png
new file mode 100644
index 0000000..8132f2b
Binary files /dev/null and b/docs/drag-corner-pi5-over-window.png differ
diff --git a/server/src/fpipe.c b/server/src/fpipe.c
index 0b99cd9..536152b 100644
--- a/server/src/fpipe.c
+++ b/server/src/fpipe.c
@@ -5,7 +5,7 @@
void fpipe_init(FPipe *p, const char *env) {
memset(p, 0, sizeof *p);
- p->mode = env && !strcmp(env, "0") ? FPIPE_OFF : env && !strcmp(env, "2") ? FPIPE_ALWAYS : FPIPE_AUTO;
+ p->mode = env && !strcmp(env, "1") ? FPIPE_AUTO : env && !strcmp(env, "2") ? FPIPE_ALWAYS : FPIPE_OFF;
}
void fpipe_note(FPipe *p, double now_ms, double cpu_ms, double period_ms) {
diff --git a/server/src/fpipe.h b/server/src/fpipe.h
index a5b011c..04b9699 100644
--- a/server/src/fpipe.h
+++ b/server/src/fpipe.h
@@ -8,8 +8,10 @@
#ifndef LORD_FPIPE_H
#define LORD_FPIPE_H
-/* LORD_PIPELINE, read once at startup: 0 off (every frame is built after the flip, as before 0.8.6),
- * 2 always, anything else (and unset) auto: on while frames are heavy (fpipe_note) */
+/* LORD_PIPELINE, read once at startup: 1 auto (on while frames are heavy, fpipe_note), 2 always, anything
+ * else (and unset) off: every frame is built after the flip, as before 0.8.6. Off by default since the
+ * Raspberry Pi 5 run of 2026-10-29: auto gave 2-5 more frames a second under an all-core load but 17-29 ms
+ * more pointer latency, and engaged even alone at 60 fps (docs/GPU.md, "The frame pipeline"). */
enum { FPIPE_OFF, FPIPE_AUTO, FPIPE_ALWAYS };
typedef struct {
int mode;
diff --git a/server/src/gpu/gpu.c b/server/src/gpu/gpu.c
index 5fad89f..19d4407 100644
--- a/server/src/gpu/gpu.c
+++ b/server/src/gpu/gpu.c
@@ -1068,7 +1068,8 @@ static void gdrag_teardown(void) {
/* GPU drag's program and textures in this context, and the self-test (or its earlier outcome). 1 = on. */
static int gdrag_setup(void) {
const char *e = getenv("LORD_GPU_DRAG");
- if (e && !strcmp(e, "0")) { fprintf(stderr, "gpu: GPU drag off (LORD_GPU_DRAG=0): the dragged window is composed by the CPU\n"); return 0; }
+ /* off by default since the Raspberry Pi 5 run of 2026-10-29: right on V3D but no measurable gain (docs/GPU.md) */
+ if (!e || strcmp(e, "1")) { fprintf(stderr, "gpu: GPU drag off (LORD_GPU_DRAG=1 turns it on): the dragged window is composed by the CPU\n"); return 0; }
GOut *o = G.cur && G.cur->used ? G.cur : &G.out[0];
if (!o->used || !eglMakeCurrent(G.dpy, o->surf, o->surf, G.ctx)) return 0;
GLint range[2] = { 0, 0 }, prec = 0;
diff --git a/server/src/gpu/gpu.h b/server/src/gpu/gpu.h
index f049d47..cc4e3cb 100644
--- a/server/src/gpu/gpu.h
+++ b/server/src/gpu/gpu.h
@@ -90,7 +90,7 @@ typedef struct GpuDrag {
const uint32_t *ref; /* LORD_GPU_VERIFY: the CPU's pixels for w (w's width a row), or NULL */
long frame; /* its number, for the log */
} GpuDrag;
-/* 1 if GPU drag may be used on that output: the shader has 24-bit floats, LORD_GPU_DRAG is not 0, the self-test
+/* 1 if GPU drag may be used on that output: LORD_GPU_DRAG is 1 (off by default), the shader has 24-bit floats, the self-test
* (every valid premultiplied combination, and a placement pass at least as large as the output, drawn
* into a framebuffer and read back) gave the CPU's pixels. gpu_init runs that test, once per GL renderer
* and version. */
diff --git a/server/src/main.c b/server/src/main.c
index 861626f..cc6f9b9 100644
--- a/server/src/main.c
+++ b/server/src/main.c
@@ -2271,7 +2271,7 @@ int main(int argc, char **argv) {
sigprocmask(SIG_BLOCK, &mask, NULL);
keylag_init(s.greeter); /* key latency trace, only with LORD_INPUT_DEBUG=1 (keylag.h) */
fpipe_init(&fpipe, getenv("LORD_PIPELINE"));
- fprintf(stderr, "lord-server: frame pipeline %s (LORD_PIPELINE: 0 off, 2 always)\n",
+ fprintf(stderr, "lord-server: frame pipeline %s (LORD_PIPELINE: unset or 0 off, 1 while frames are heavy, 2 always)\n",
fpipe.mode == FPIPE_OFF ? "off" : fpipe.mode == FPIPE_ALWAYS ? "always" : "while frames are heavy");
int sfd = signalfd(-1, &mask, SFD_CLOEXEC);
diff --git a/server/tests/fpipe_test.c b/server/tests/fpipe_test.c
index d41f879..d4b7cc7 100644
--- a/server/tests/fpipe_test.c
+++ b/server/tests/fpipe_test.c
@@ -19,8 +19,8 @@ static void note(FPipe *p, double cpu_ms, double period_ms) { clock_ms += 16.67;
static void test_mode(void) {
FPipe p;
- fpipe_init(&p, NULL);
- CHECK(p.mode == FPIPE_AUTO && !fpipe_engaged(&p));
+ fpipe_init(&p, NULL); /* unset: off (the default since the Pi 5 run) */
+ CHECK(p.mode == FPIPE_OFF && !fpipe_engaged(&p));
fpipe_init(&p, "0");
CHECK(p.mode == FPIPE_OFF && !fpipe_engaged(&p));
note(&p, 30, 16.67); /* off stays off, however heavy */
@@ -32,13 +32,16 @@ static void test_mode(void) {
CHECK(fpipe_engaged(&p));
fpipe_init(&p, "1");
CHECK(p.mode == FPIPE_AUTO);
- fpipe_init(&p, "yes"); /* anything else: auto */
- CHECK(p.mode == FPIPE_AUTO);
+ CHECK(!fpipe_engaged(&p));
+ fpipe_init(&p, "yes"); /* anything else: off */
+ CHECK(p.mode == FPIPE_OFF);
+ fpipe_init(&p, "");
+ CHECK(p.mode == FPIPE_OFF);
}
static void test_auto(void) {
FPipe p;
- fpipe_init(&p, NULL);
+ fpipe_init(&p, "1");
note(&p, 13, 16.67); /* one heavy frame: not yet */
CHECK(!fpipe_engaged(&p));
note(&p, 5, 16.67); /* the run is broken */
@@ -89,7 +92,7 @@ typedef struct { long shown, prepares, spins, max_latency; } Sim;
static Sim simulate(int mode, long cpu, long sub, long gpu, int animate, long n) {
const long P = 16667;
FPipe fp;
- fpipe_init(&fp, mode == FPIPE_OFF ? "0" : mode == FPIPE_ALWAYS ? "2" : NULL);
+ fpipe_init(&fp, mode == FPIPE_OFF ? "0" : mode == FPIPE_ALWAYS ? "2" : "1");
Sim r = { 0, 0, 0, 0 };
long t = 0, flip_at = -1; /* when the pending flip lands (-1: none) */
int prep = FPIPE_NONE;
@@ -165,7 +168,7 @@ static void test_sim(void) {
* longer than FPIPE_IDLE_MS lets go (a heavy one counts as the first of the two that engage it again). */
static void test_idle(void) {
FPipe p;
- fpipe_init(&p, NULL);
+ fpipe_init(&p, "1");
fpipe_note(&p, 1000, 13, 16.67);
fpipe_note(&p, 1016.7, 13, 16.67);
CHECK(fpipe_engaged(&p));
@@ -198,7 +201,7 @@ static void test_idle(void) {
CHECK(!fpipe_engaged(&p));
/* a frame-by-frame run: a heavy drag engages it, the desktop goes idle for 2 s, then a light click: the
* click's frame lets go, so the next input waits for the flip as without the pipeline */
- fpipe_init(&p, NULL);
+ fpipe_init(&p, "1");
double t = 1000;
for (int i = 0; i < 100; i++, t += 16.67) fpipe_note(&p, t, 13, 16.67);
CHECK(fpipe_engaged(&p));
@@ -217,7 +220,7 @@ static void test_idle(void) {
static void sim_callbacks(int mode, int hold, long n, long *shown, long *cbs) {
const long P = 16667, cpu = 2000, gpu = 2000;
FPipe fp;
- fpipe_init(&fp, mode == FPIPE_OFF ? "0" : mode == FPIPE_ALWAYS ? "2" : NULL);
+ fpipe_init(&fp, mode == FPIPE_OFF ? "0" : mode == FPIPE_ALWAYS ? "2" : "1");
long t = 0, flip_at = -1;
int prep = FPIPE_NONE, prep_js = 0, app_new = 1;
*shown = *cbs = 0;
diff --git a/web/content/faq/faq.json b/web/content/faq/faq.json
index 6fa72ef..d3c50ff 100644
--- a/web/content/faq/faq.json
+++ b/web/content/faq/faq.json
@@ -703,9 +703,9 @@
"pt": "Posso medir quão rápido o LordOS roda no meu computador?"
},
"a": {
- "en": "Coming in 0.8.6 (in development; the latest release is 0.8.5-beta): System Information gets a Performance tab with LordBench, a quick and a full test of the processor, memory, graphics, video decoding, disk and sustained load, and of LordOS's own interface work (laying out and drawing a desktop scene, and shaping text in five scripts), run in an isolated helper that checks its own sandbox first and that stops near the temperature limit (on a Raspberry Pi also at 80 °C, where the board's firmware starts slowing the processor down; tested so far on simulated system files, not on a real Pi). Results are shown against reference machines measured the same way, with the conditions of each run, never as one score, and nothing is sent anywhere. A separate desktop test measures whether the desktop stays smooth, and how fast the pointer reaches the screen, while the computer is busy, and a boot test restarts it several times and keeps the median time to the login screen (a Raspberry Pi 5 with a monitor reaches it in about 6 seconds). What that desktop test found is being fixed in 0.8.6: the compositor now gets more CPU weight than any app and the lowest real-time priority, so it no longer waits behind a busy app. On the reference virtual machine the desktop under load now measures as without load; on a Raspberry Pi 5 with its monitor the loaded test went from 24 to 29–30 frames a second. The test's scene now has a square that really turns (before, it stood still), which makes it heavier, and the work on a dragged window's frame, also in development, runs that heavier scene at 60 frames a second without load (53–58 before) and at 30 under load: on the Pi a busy app still halves the frame rate, because building a frame, the graphics chip's work and showing it run one after another and miss the screen's 60 Hz. Painting the next frame while the previous one waits for the screen is built and is still to be measured on the Pi. <!-- PI-RESULT: FAQ LordBench answer, the Pi 5 with its monitor and the final build: the under-load frame rate with the frame pipeline (and GPU drag if on by default); if it is near 60, replace the halving sentence -->",
- "es": "Llega en la 0.8.6 (en desarrollo; la última versión es la 0.8.5-beta): Información del sistema suma una pestaña Rendimiento con LordBench, una prueba rápida y una completa del procesador, la memoria, los gráficos, la decodificación de video, el disco y la carga sostenida, y del propio trabajo de la interfaz de LordOS (el diseño y dibujo de una escena de escritorio y la composición de texto en cinco escrituras), que corre en un ayudante aislado que primero comprueba su propio aislamiento y se detiene cerca del límite de temperatura (en una Raspberry Pi también a los 80 °C, donde el firmware de la placa empieza a bajar la velocidad del procesador; por ahora probado con archivos de sistema simulados, no en una Pi real). Los resultados se muestran frente a máquinas de referencia medidas de la misma forma, con las condiciones de cada prueba, nunca como un único puntaje, y no se envía nada a ningún lado. Una prueba aparte mide si el escritorio sigue fluido, y cuánto tarda el puntero en llegar a la pantalla, mientras la computadora está ocupada, y una prueba de arranque la reinicia varias veces y se queda con la mediana del tiempo hasta la pantalla de inicio de sesión (una Raspberry Pi 5 con monitor llega en unos 6 segundos). Lo que encontró esa prueba de escritorio se está corrigiendo en la 0.8.6: el compositor ahora recibe más peso de CPU que cualquier app y la menor prioridad de tiempo real, así que ya no espera detrás de una app ocupada. En la máquina virtual de referencia el escritorio con carga ahora mide igual que sin carga; en una Raspberry Pi 5 con su monitor la prueba con carga pasó de 24 a 29–30 cuadros por segundo. La escena de la prueba ahora tiene un cuadrado que gira de verdad (antes estaba quieto), lo que la hace más pesada, y el trabajo sobre el cuadro de una ventana que se arrastra, también en desarrollo, lleva esa escena más pesada a 60 cuadros por segundo sin carga (antes 53–58) y a 30 con carga: en la Pi una app ocupada todavía reduce a la mitad los cuadros por segundo, porque armar el cuadro, el trabajo del chip gráfico y mostrarlo van uno después del otro y no entran en los 60 Hz de la pantalla. Pintar el cuadro siguiente mientras el anterior espera la pantalla ya está hecho y falta medirlo en la Pi. <!-- PI-RESULT: FAQ LordBench answer, the Pi 5 with its monitor and the final build: the under-load frame rate with the frame pipeline (and GPU drag if on by default); if it is near 60, replace the halving sentence -->",
- "pt": "Chega na 0.8.6 (em desenvolvimento; a última versão é a 0.8.5-beta): Informações do sistema ganha uma aba Desempenho com o LordBench, um teste rápido e um completo do processador, da memória, dos gráficos, da decodificação de vídeo, do disco e da carga contínua, e do próprio trabalho da interface do LordOS (o layout e o desenho de uma cena de desktop e a composição de texto em cinco escritas), executado num auxiliar isolado que primeiro verifica o próprio isolamento e que para perto do limite de temperatura (num Raspberry Pi também aos 80 °C, onde o firmware da placa começa a reduzir a velocidade do processador; por enquanto testado com arquivos de sistema simulados, não num Pi real). Os resultados aparecem frente a máquinas de referência medidas da mesma forma, com as condições de cada teste, nunca como uma única pontuação, e nada é enviado a lugar nenhum. Um teste à parte mede se o desktop continua fluido, e quanto o ponteiro demora para chegar à tela, enquanto o computador está ocupado, e um teste de boot o reinicia várias vezes e fica com a mediana do tempo até a tela de login (um Raspberry Pi 5 com monitor chega em cerca de 6 segundos). O que esse teste de desktop encontrou está sendo corrigido na 0.8.6: o compositor agora recebe mais peso de CPU que qualquer app e a menor prioridade de tempo real, então não espera mais atrás de um app ocupado. Na máquina virtual de referência o desktop com carga agora mede igual a sem carga; num Raspberry Pi 5 com seu monitor o teste com carga passou de 24 para 29–30 quadros por segundo. A cena do teste agora tem um quadrado que gira de verdade (antes ficava parado), o que a deixa mais pesada, e o trabalho no quadro de uma janela arrastada, também em desenvolvimento, leva essa cena mais pesada a 60 quadros por segundo sem carga (antes 53–58) e a 30 com carga: no Pi um app ocupado ainda reduz pela metade os quadros por segundo, porque montar o quadro, o trabalho do chip gráfico e mostrá-lo vêm um depois do outro e não cabem nos 60 Hz da tela. Pintar o quadro seguinte enquanto o anterior espera a tela já está pronto e falta medi-lo no Pi. <!-- PI-RESULT: FAQ LordBench answer, the Pi 5 with its monitor and the final build: the under-load frame rate with the frame pipeline (and GPU drag if on by default); if it is near 60, replace the halving sentence -->"
+ "en": "Coming in 0.8.6 (in development; the latest release is 0.8.5-beta): System Information gets a Performance tab with LordBench, a quick and a full test of the processor, memory, graphics, video decoding, disk and sustained load, and of LordOS's own interface work (laying out and drawing a desktop scene, and shaping text in five scripts), run in an isolated helper that checks its own sandbox first and that stops near the temperature limit (on a Raspberry Pi also at 80 °C, where the board's firmware starts slowing the processor down; tested so far on simulated system files, not on a real Pi). Results are shown against reference machines measured the same way, with the conditions of each run, never as one score, and nothing is sent anywhere. A separate desktop test measures whether the desktop stays smooth, and how fast the pointer reaches the screen, while the computer is busy, and a boot test restarts it several times and keeps the median time to the login screen (a Raspberry Pi 5 with a monitor reaches it in about 6 seconds). What that desktop test found is being fixed in 0.8.6: the compositor now gets more CPU weight than any app and the lowest real-time priority, so it no longer waits behind a busy app. On the reference virtual machine the desktop under load now measures as without load; on a Raspberry Pi 5 with its monitor the loaded test went from 24 to 29–30 frames a second. The test's scene now has a square that really turns (before, it stood still), which makes it heavier, and the work on a dragged window's frame, also in development, runs that heavier scene at 60 frames a second without load (53–58 before) and at about 31 under load: on the Pi a busy app still halves the frame rate. Two more changes were measured on the Pi and are off by default, because they gave too little: drawing the dragged window on the graphics chip (correct, no gain) and painting the next frame while the previous one waits for the screen (33–36 frames a second under load, but the pointer reached the screen 17–29 ms later). What remains is the graphics chip's time per frame, which grows from 1.5 to 14–16 ms under load without the chip slowing down or overheating.",
+ "es": "Llega en la 0.8.6 (en desarrollo; la última versión es la 0.8.5-beta): Información del sistema suma una pestaña Rendimiento con LordBench, una prueba rápida y una completa del procesador, la memoria, los gráficos, la decodificación de video, el disco y la carga sostenida, y del propio trabajo de la interfaz de LordOS (el diseño y dibujo de una escena de escritorio y la composición de texto en cinco escrituras), que corre en un ayudante aislado que primero comprueba su propio aislamiento y se detiene cerca del límite de temperatura (en una Raspberry Pi también a los 80 °C, donde el firmware de la placa empieza a bajar la velocidad del procesador; por ahora probado con archivos de sistema simulados, no en una Pi real). Los resultados se muestran frente a máquinas de referencia medidas de la misma forma, con las condiciones de cada prueba, nunca como un único puntaje, y no se envía nada a ningún lado. Una prueba aparte mide si el escritorio sigue fluido, y cuánto tarda el puntero en llegar a la pantalla, mientras la computadora está ocupada, y una prueba de arranque la reinicia varias veces y se queda con la mediana del tiempo hasta la pantalla de inicio de sesión (una Raspberry Pi 5 con monitor llega en unos 6 segundos). Lo que encontró esa prueba de escritorio se está corrigiendo en la 0.8.6: el compositor ahora recibe más peso de CPU que cualquier app y la menor prioridad de tiempo real, así que ya no espera detrás de una app ocupada. En la máquina virtual de referencia el escritorio con carga ahora mide igual que sin carga; en una Raspberry Pi 5 con su monitor la prueba con carga pasó de 24 a 29–30 cuadros por segundo. La escena de la prueba ahora tiene un cuadrado que gira de verdad (antes estaba quieto), lo que la hace más pesada, y el trabajo sobre el cuadro de una ventana que se arrastra, también en desarrollo, lleva esa escena más pesada a 60 cuadros por segundo sin carga (antes 53–58) y a unos 31 con carga: en la Pi una app ocupada todavía reduce a la mitad los cuadros por segundo. Otros dos cambios se midieron en la Pi y quedan apagados por defecto, porque dieron muy poco: dibujar la ventana que se arrastra en el chip gráfico (correcto, sin ganancia) y pintar el cuadro siguiente mientras el anterior espera la pantalla (33–36 cuadros por segundo con carga, pero el puntero llegó a la pantalla 17–29 ms más tarde). Lo que queda es el tiempo del chip gráfico por cuadro, que con carga crece de 1,5 a 14–16 ms sin que el chip baje su velocidad ni se recaliente.",
+ "pt": "Chega na 0.8.6 (em desenvolvimento; a última versão é a 0.8.5-beta): Informações do sistema ganha uma aba Desempenho com o LordBench, um teste rápido e um completo do processador, da memória, dos gráficos, da decodificação de vídeo, do disco e da carga contínua, e do próprio trabalho da interface do LordOS (o layout e o desenho de uma cena de desktop e a composição de texto em cinco escritas), executado num auxiliar isolado que primeiro verifica o próprio isolamento e que para perto do limite de temperatura (num Raspberry Pi também aos 80 °C, onde o firmware da placa começa a reduzir a velocidade do processador; por enquanto testado com arquivos de sistema simulados, não num Pi real). Os resultados aparecem frente a máquinas de referência medidas da mesma forma, com as condições de cada teste, nunca como uma única pontuação, e nada é enviado a lugar nenhum. Um teste à parte mede se o desktop continua fluido, e quanto o ponteiro demora para chegar à tela, enquanto o computador está ocupado, e um teste de boot o reinicia várias vezes e fica com a mediana do tempo até a tela de login (um Raspberry Pi 5 com monitor chega em cerca de 6 segundos). O que esse teste de desktop encontrou está sendo corrigido na 0.8.6: o compositor agora recebe mais peso de CPU que qualquer app e a menor prioridade de tempo real, então não espera mais atrás de um app ocupado. Na máquina virtual de referência o desktop com carga agora mede igual a sem carga; num Raspberry Pi 5 com seu monitor o teste com carga passou de 24 para 29–30 quadros por segundo. A cena do teste agora tem um quadrado que gira de verdade (antes ficava parado), o que a deixa mais pesada, e o trabalho no quadro de uma janela arrastada, também em desenvolvimento, leva essa cena mais pesada a 60 quadros por segundo sem carga (antes 53–58) e a cerca de 31 com carga: no Pi um app ocupado ainda reduz pela metade os quadros por segundo. Outras duas mudanças foram medidas no Pi e ficam desligadas por padrão, porque deram muito pouco: desenhar a janela arrastada no chip gráfico (correto, sem ganho) e pintar o quadro seguinte enquanto o anterior espera a tela (33–36 quadros por segundo com carga, mas o ponteiro chegou à tela 17–29 ms mais tarde). O que resta é o tempo do chip gráfico por quadro, que com carga cresce de 1,5 para 14–16 ms sem que o chip reduza a velocidade nem esquente demais."
}
}
]
diff --git a/web/content/features/own-desktop.en.md b/web/content/features/own-desktop.en.md
index 2ff2f16..9bfea88 100644
--- a/web/content/features/own-desktop.en.md
+++ b/web/content/features/own-desktop.en.md
@@ -65,7 +65,7 @@ LordOS aims at modest machines. A few real measurements from the project's test
- When the machine has no 3D-capable card, `lord-server` doesn't even load Mesa and stays at about 32 MB of RSS (`docs/GPU.md`).
- Since 0.8.5 the login screen no longer stays in memory behind your session: it closes 10 seconds after a session takes the screen and starts again in a few milliseconds when you lock or switch user. On a VMware VM the whole system went from **603 to 548 MB** in use, and locking the screen went from 903 ms to **141 ms**.
- On virtual graphics cards that complete every page flip at once (VMware's `vmwgfx`), 0.8.5 paces frames to the display's refresh instead of drawing 500–580 frames a second: **59.8 frames a second** at 60 Hz, 99th percentile 18.4 ms. Every boot's time is shown in About LordOS → Startup time and kept for comparing versions (`docs/RESULTS.md`).
-- **In development for 0.8.6:** on a Raspberry Pi 5 with a 1920×1080 monitor, LordBench's desktop test moves a window with a turning square inside at **59.8–60 frames a second** (53–58 before the work on a dragged window's frame, which keeps every pixel the same), and at 30 while every core is busy with a low-priority load (24–25 before; `docs/BENCHMARK.md`). <!-- PI-RESULT: own-desktop, the Pi 5 with its monitor and the final build: the under-load frame rate with the frame pipeline (and GPU drag if on by default) -->
+- **In development for 0.8.6 (the latest release is 0.8.5 Beta):** on a Raspberry Pi 5 with a 1920×1080 monitor, LordBench's desktop test moves a window with a turning square inside at **59.8–60 frames a second** (53–58 before the work on a dragged window's frame, which keeps every pixel the same), and at about 31 (30.5–31.1) while every core is busy with a low-priority load (24–25 before; `docs/BENCHMARK.md`). Drawing the dragged window on the graphics chip and painting the next frame while the previous one waits for the screen were measured there too and are off by default: the first is exact but gave no measurable gain, the second gave 33–36 frames a second under load but the pointer reached the screen 17–29 ms later.
These numbers come from virtual machines and one board, not from a range of real PCs. They are a starting point, not a promise for every machine.
@@ -82,7 +82,7 @@ The compositor drives several displays at once, extended or mirrored, and draws
- **Real GPUs are not verified yet.** The GPU path was exercised with Mesa's software renderer in virtual machines. Testing on real AMD and Nvidia cards is still pending (`docs/GPU.md`).
- **Multiple displays were tested with two virtual heads**, not with real monitors, laptop panels or DisplayPort hubs (`docs/DISPLAYS.md`).
- **The Raspberry Pi 5 has been tested with one HDMI monitor only.** Since 0.8.4.1 the image shows the login screen and the desktop on an HDMI monitor from the first boot, and LordBench measured it there; two monitors and 4K have not been tested on the board yet (`docs/RASPBERRY.md`).
-- **On the Raspberry Pi 5 a busy app still halves the desktop's frame rate:** 30 instead of 60 frames a second in LordBench's desktop test while every core is busy. Painting the next frame while the previous one waits for the screen is built for 0.8.6 and not yet measured (`docs/GPU.md`). <!-- PI-RESULT: own-desktop limit, remove or reword with the measured number if the frame pipeline brings the Pi 5 under load near 60 fps -->
+- **On the Raspberry Pi 5 a busy app still halves the desktop's frame rate:** about 31 instead of 60 frames a second in LordBench's desktop test while every core is busy. Under that load the graphics chip takes 14–16 ms per frame instead of 1.5, with no clock or thermal throttling (most likely the cores and the chip competing for memory, not proven yet); fewer pixels sent and composed per frame is the next step (`docs/GPU.md`).
- **X11 apps run through Xwayland since 0.8.3,** sharp only at 100 % scale and able to see each other, as on any X11 desktop. Drag and drop between Linux apps and LordOS input methods inside Linux apps are pending (`docs/WAYLAND.md`).
- **Accessibility is mostly ahead of us:** today there is a "reduce motion" setting; a screen reader, zoom and high contrast are on the roadmap.
diff --git a/web/content/features/own-desktop.es.md b/web/content/features/own-desktop.es.md
index b626d73..5e703b1 100644
--- a/web/content/features/own-desktop.es.md
+++ b/web/content/features/own-desktop.es.md
@@ -65,7 +65,7 @@ LordOS apunta a máquinas modestas. Algunas mediciones reales de los registros d
- Cuando la máquina no tiene una placa con 3D, `lord-server` ni siquiera carga Mesa y se queda en unos 32 MB de RSS (`docs/GPU.md`).
- Desde 0.8.5 la pantalla de ingreso ya no queda en memoria detrás de tu sesión: se cierra 10 segundos después de que una sesión toma la pantalla y vuelve a arrancar en pocos milisegundos cuando bloqueás o cambiás de usuario. En una VM de VMware todo el sistema pasó de **603 a 548 MB** en uso, y bloquear la pantalla pasó de 903 ms a **141 ms**.
- En placas de video virtuales que completan cada cambio de cuadro al instante (`vmwgfx`, de VMware), 0.8.5 ajusta los cuadros a la frecuencia de la pantalla en vez de dibujar 500–580 por segundo: **59,8 cuadros por segundo** a 60 Hz, percentil 99 de 18,4 ms. El tiempo de cada arranque se muestra en Acerca de LordOS → Tiempo de inicio y se guarda para comparar versiones (`docs/RESULTS.md`).
-- **En desarrollo para la 0.8.6:** en una Raspberry Pi 5 con un monitor de 1920×1080, la prueba de escritorio de LordBench mueve una ventana con un cuadrado que gira adentro a **59,8–60 cuadros por segundo** (53–58 antes del trabajo sobre el cuadro de una ventana que se arrastra, que deja cada píxel igual), y a 30 mientras todos los núcleos están ocupados con una carga de baja prioridad (24–25 antes; `docs/BENCHMARK.md`). <!-- PI-RESULT: own-desktop, the Pi 5 with its monitor and the final build: the under-load frame rate with the frame pipeline (and GPU drag if on by default) -->
+- **En desarrollo para la 0.8.6 (la última versión es la 0.8.5 Beta):** en una Raspberry Pi 5 con un monitor de 1920×1080, la prueba de escritorio de LordBench mueve una ventana con un cuadrado que gira adentro a **59,8–60 cuadros por segundo** (53–58 antes del trabajo sobre el cuadro de una ventana que se arrastra, que deja cada píxel igual), y a unos 31 (30,5–31,1) mientras todos los núcleos están ocupados con una carga de baja prioridad (24–25 antes; `docs/BENCHMARK.md`). Dibujar la ventana que se arrastra en el chip gráfico y pintar el cuadro siguiente mientras el anterior espera la pantalla también se midieron ahí y están apagados por defecto: lo primero es exacto pero no dio una ganancia medible, lo segundo dio 33–36 cuadros por segundo con carga pero el puntero llegó a la pantalla 17–29 ms más tarde.
Estos números salen de máquinas virtuales y de una sola placa, no de una variedad de PCs reales. Son un punto de partida, no una promesa para cualquier máquina.
@@ -82,7 +82,7 @@ El compositor maneja varias pantallas a la vez, extendidas o en espejo, y dibuja
- **Las GPU reales todavía no están verificadas.** El camino por GPU se probó con el renderizador por software de Mesa en máquinas virtuales. Falta probar en placas AMD y Nvidia reales (`docs/GPU.md`).
- **Las pantallas múltiples se probaron con dos salidas virtuales**, no con monitores reales, paneles de notebook ni hubs DisplayPort (`docs/DISPLAYS.md`).
- **La Raspberry Pi 5 solo se probó con un monitor HDMI.** Desde la 0.8.4.1 la imagen muestra la pantalla de ingreso y el escritorio en un monitor HDMI desde el primer arranque, y LordBench la midió así; dos monitores y 4K todavía no se probaron en la placa (`docs/RASPBERRY.md`).
-- **En la Raspberry Pi 5 una app ocupada todavía reduce a la mitad los cuadros por segundo del escritorio:** 30 en vez de 60 en la prueba de escritorio de LordBench mientras todos los núcleos están ocupados. Pintar el cuadro siguiente mientras el anterior espera la pantalla está hecho para la 0.8.6 y todavía no se midió (`docs/GPU.md`). <!-- PI-RESULT: own-desktop limit, remove or reword with the measured number if the frame pipeline brings the Pi 5 under load near 60 fps -->
+- **En la Raspberry Pi 5 una app ocupada todavía reduce a la mitad los cuadros por segundo del escritorio:** unos 31 en vez de 60 en la prueba de escritorio de LordBench mientras todos los núcleos están ocupados. Con esa carga el chip gráfico tarda 14–16 ms por cuadro en vez de 1,5, sin bajar su frecuencia ni por temperatura (lo más probable es que los núcleos y el chip compitan por la memoria, todavía sin demostrar); enviar y componer menos píxeles por cuadro es el paso siguiente (`docs/GPU.md`).
- **Las apps X11 funcionan con Xwayland desde 0.8.3,** nítidas solo al 100 % de escala y pudiendo verse entre sí, como en cualquier escritorio X11. Arrastrar y soltar entre apps de Linux y los métodos de entrada de LordOS dentro de apps de Linux están pendientes (`docs/WAYLAND.md`).
- **La accesibilidad está mayormente por delante:** hoy hay un ajuste de "reducir movimiento"; un lector de pantalla, el zoom y el alto contraste están en la hoja de ruta.
diff --git a/web/content/features/own-desktop.pt.md b/web/content/features/own-desktop.pt.md
index 93a225e..6f80bc3 100644
--- a/web/content/features/own-desktop.pt.md
+++ b/web/content/features/own-desktop.pt.md
@@ -65,7 +65,7 @@ O LordOS mira máquinas modestas. Algumas medições reais dos registros de test
- Quando a máquina não tem placa com 3D, o `lord-server` nem carrega o Mesa e fica em torno de 32 MB de RSS (`docs/GPU.md`).
- Desde a 0.8.5 a tela de login não fica mais na memória atrás da sua sessão: ela fecha 10 segundos depois que uma sessão assume a tela e volta a iniciar em poucos milissegundos quando você bloqueia ou troca de usuário. Numa VM do VMware o sistema inteiro passou de **603 para 548 MB** em uso, e bloquear a tela passou de 903 ms para **141 ms**.
- Em placas de vídeo virtuais que concluem cada troca de quadro na hora (`vmwgfx`, do VMware), a 0.8.5 ajusta os quadros à frequência da tela em vez de desenhar 500–580 por segundo: **59,8 quadros por segundo** a 60 Hz, percentil 99 de 18,4 ms. O tempo de cada boot aparece em Sobre o LordOS → Tempo de inicialização e fica guardado para comparar versões (`docs/RESULTS.md`).
-- **Em desenvolvimento para a 0.8.6:** num Raspberry Pi 5 com um monitor de 1920×1080, o teste de desktop do LordBench move uma janela com um quadrado que gira dentro a **59,8–60 quadros por segundo** (53–58 antes do trabalho no quadro de uma janela arrastada, que deixa cada pixel igual), e a 30 enquanto todos os núcleos estão ocupados com uma carga de baixa prioridade (24–25 antes; `docs/BENCHMARK.md`). <!-- PI-RESULT: own-desktop, the Pi 5 with its monitor and the final build: the under-load frame rate with the frame pipeline (and GPU drag if on by default) -->
+- **Em desenvolvimento para a 0.8.6 (a última versão é a 0.8.5 Beta):** num Raspberry Pi 5 com um monitor de 1920×1080, o teste de desktop do LordBench move uma janela com um quadrado que gira dentro a **59,8–60 quadros por segundo** (53–58 antes do trabalho no quadro de uma janela arrastada, que deixa cada pixel igual), e a cerca de 31 (30,5–31,1) enquanto todos os núcleos estão ocupados com uma carga de baixa prioridade (24–25 antes; `docs/BENCHMARK.md`). Desenhar a janela arrastada no chip gráfico e pintar o quadro seguinte enquanto o anterior espera a tela também foram medidos ali e estão desligados por padrão: o primeiro é exato mas não deu ganho mensurável, o segundo deu 33–36 quadros por segundo com carga mas o ponteiro chegou à tela 17–29 ms mais tarde.
Esses números vêm de máquinas virtuais e de uma placa, não de uma variedade de PCs reais. São um ponto de partida, não uma promessa para toda máquina.
@@ -82,7 +82,7 @@ O compositor controla várias telas ao mesmo tempo, estendidas ou espelhadas, e
- **GPUs reais ainda não foram verificadas.** O caminho da GPU foi exercitado com o renderizador por software do Mesa em máquinas virtuais. O teste em placas AMD e Nvidia reais ainda está pendente (`docs/GPU.md`).
- **Várias telas foram testadas com duas saídas virtuais**, não com monitores reais, painéis de notebook ou hubs DisplayPort (`docs/DISPLAYS.md`).
- **O Raspberry Pi 5 só foi testado com um monitor HDMI.** Desde a 0.8.4.1 a imagem mostra a tela de login e o desktop num monitor HDMI desde o primeiro boot, e o LordBench o mediu assim; dois monitores e 4K ainda não foram testados na placa (`docs/RASPBERRY.md`).
-- **No Raspberry Pi 5 um app ocupado ainda reduz pela metade os quadros por segundo do desktop:** 30 em vez de 60 no teste de desktop do LordBench enquanto todos os núcleos estão ocupados. Pintar o quadro seguinte enquanto o anterior espera a tela está pronto para a 0.8.6 e ainda não foi medido (`docs/GPU.md`). <!-- PI-RESULT: own-desktop limit, remove or reword with the measured number if the frame pipeline brings the Pi 5 under load near 60 fps -->
+- **No Raspberry Pi 5 um app ocupado ainda reduz pela metade os quadros por segundo do desktop:** cerca de 31 em vez de 60 no teste de desktop do LordBench enquanto todos os núcleos estão ocupados. Com essa carga o chip gráfico leva 14–16 ms por quadro em vez de 1,5, sem reduzir a frequência nem por temperatura (o mais provável é que os núcleos e o chip disputem a memória, ainda sem comprovar); enviar e compor menos pixels por quadro é o próximo passo (`docs/GPU.md`).
- **Os apps X11 rodam pelo Xwayland desde a 0.8.3,** nítidos só em 100 % de escala e podendo ver uns aos outros, como em qualquer desktop X11. Arrastar e soltar entre apps Linux e os métodos de entrada do LordOS dentro de apps Linux estão pendentes (`docs/WAYLAND.md`).
- **A acessibilidade ainda está quase toda pela frente:** hoje existe um ajuste para "reduzir movimento"; leitor de tela, zoom e alto contraste estão no roadmap.
diff --git a/web/content/paper/paper.en.md b/web/content/paper/paper.en.md
index 3bf2a61..c351d78 100644
--- a/web/content/paper/paper.en.md
+++ b/web/content/paper/paper.en.md
@@ -457,7 +457,7 @@ All figures below were measured by the project and are documented in the files c
- **Software vblank (0.8.5).** A virtual card that completes page flips at once (VMware's `vmwgfx`) made the compositor and its apps draw 500–580 frames a second on a 60 Hz display; LordOS now detects it and paces frames to the refresh on a fixed grid: 59.8 frames a second, p99 18.4 ms, no frame over budget (`results/0.8.5~rc1-beta/vmware-fusion`). On the released 0.8.5-beta, the Test Bench with its 3D view on the same machine measured 59.83 frames a second over 1,796 frames, p99 17.9 ms, one frame over budget, 1,795 presented (`results/0.8.5-beta/vmware-fusion`). The same grid also paces sessions without a monitor, so waiting in whole milliseconds no longer turns 60 frames a second into 57.
- **Dragging on the GPU path (0.8.5 fix).** A dragged window is painted from a cached layer; on the GPU path every fully transparent pixel of that layer was taken for a Linux window's hole, and now only pixels inside an app surface are. In 0.8.5-beta small black squares could still show at a dragged window's rounded corners, on the CPU and GPU paths: the layer's corner restore took the saved pixel as opaque. In 0.8.6 (in development) it mixes both pixels alpha included, so the layer stays transparent outside the curve; a test compares each corner with a full repaint on both paths (§10.2).
-- **A cheaper drag frame (0.8.6, in development).** A dragged window's frame now paints only the part of its layer that changed and only the changed part of what is below it, with the same pixels: 2,417 recorded frame hashes per path must match, and the one approved change brings rounded corners below the window one level closer to a full repaint. On the GPU path the window itself can be composed by the GPU with the CPU's exact arithmetic, after a self-test of every pixel combination ("GPU drag"), and the next frame can be painted while the previous flip is pending. Results on the Raspberry Pi 5 are in §7.4.
+- **A cheaper drag frame (0.8.6, in development).** A dragged window's frame now paints only the part of its layer that changed and only the changed part of what is below it, with the same pixels: 2,417 recorded frame hashes per path must match, and the one approved change brings rounded corners below the window one level closer to a full repaint. On the GPU path the window itself can be composed by the GPU with the CPU's exact arithmetic, after a self-test of every pixel combination ("GPU drag"), and the next frame can be painted while the previous flip is pending; both were measured on the Raspberry Pi 5 and are off by default. Results on the Raspberry Pi 5 are in §7.4.
- Dragging a window on one 1280×800 display on the CPU path: about 6.7–6.9 ms of work per frame, around 120 frames per second (VM 118, `docs/DISPLAYS.md`).
- The same window on a 2560×1600 display at 150 %: about 5.1 ms per frame.
- Video: painting straight from the decoded frame when only an opaque video changed brought `lord-server` from 42 % to 13 % of a core for a windowed 1080p video, and from 92 % to 15 % fullscreen (`docs/ROADMAP.md`, media).
@@ -485,11 +485,11 @@ The Raspberry Pi 5 is the only supported board. Results on a real board (16 GB,
**Fans.** On the Pi 5 in a test case, `lord-fand` kept the fan off at 50–53 °C during a 4-thread load (the aluminium case acts as a heatsink), drove it to 55 % (4,500 RPM) and full speed (7,400 RPM) with test curves, and restored the kernel's own settings after `SIGTERM` and `kill -9` (`docs/FANS.md`).
-**Monitor and image.** Since 0.8.4.1 the Raspberry Pi 5 image shows the desktop on an HDMI monitor at the first boot (the display driver line in `config.txt` now comes after the firmware's auto-detection lines, and LordOS waits up to 30 s for the driver), sets the clock from the network, and ships Chromium and Firefox ESR. Since 0.8.4 the LordOS Pi kernel (`6.18.57-lordos.3-rpi-2712`) also destroys the connections of a blocked app. **Measured on a monitor (LordBench, 0.8.6 in development):** the 0.8.5 image booted with a 1920×1080 60 Hz monitor on either HDMI port reaches the login screen 5.99 s after the kernel starts (systemd: 2.1 s kernel, 4.2 s userspace). With GPU composition (V3D) a window moved by the compositor keeps 59.4 frames per second, with a frame built in 10.9 ms (median) and 13.0 ms (99th percentile) and 1.0 % of frames late; under an all-core load at the lowest priority it falls to 24 frames per second with 96.5 % late, a problem LordBench found: the compositor's cgroup weighed the same as the load's, so the load's low priority did not count. Giving the compositor ten times the CPU weight of an app raised the same test, run without the monitor, from 43–45 to 56–57 frames per second (31–33 % → 7–8 % late) and brought a pointer move to the screen in 22 ms instead of 32 ms (median); with the monitor it was measured only together with the real-time priority below. The compositor's main and paint threads now also run at the lowest real-time priority, which lord-sessiond allows and lord-server drops before it starts anything, so no app inherits it; on VM 116 under load that took late frames from 2.7–2.9 % to 0.28 % and the slowest 1 % of pointer moves from 31–32 to 25 ms, as without load, with the load getting the same CPU time. On the Pi 5 with its monitor the two changes took the loaded test from 24 to 29–30 frames per second and the compositor no longer waits for a CPU, but under the load a frame takes 15–16 ms to build instead of 7, so it misses the 60 Hz refresh; that cause is still being looked for. LordBench's scene had a square meant to turn that stood still, because it was set through a style key the engine lacks; it now turns, which makes the test heavier: with it, that code showed 53–58 frames per second alone and 24–25 under the load. In development for 0.8.6, a dragged window's frame paints only what changed (the changed part of the window's layer and of what is below it), with the same pixels, checked frame by frame against recorded hashes; with that, the same test shows 59.8–60 frames per second alone (99th percentile 11.3–11.6 ms) and 30 under the load, where a frame is built in 12.9 ms (median) instead of about 20. Under the load nearly every frame is still late, because building a frame, the GPU's work and the flip run one after another and miss the 16.7 ms refresh. Composing the dragged window on the GPU stalled in that run (52 frames per second alone), so it was measured off; painting the next frame while the previous one waits for the flip is built and not yet measured on the board. <!-- PI-RESULT: §7.4, the Pi 5 with its monitor and the final build: LordBench Desktop impact alone and under load (fps, late %, build p50) with the defaults (GPU drag where its self-test passes, the frame pipeline while frames are heavy), with LORD_GPU_DRAG=0 and with LORD_PIPELINE=0; replace the GPU drag sentence and "not yet measured on the board" with what was measured, and keep the 53–58 / 24–25 baseline --> In a 3-minute all-core load with the fan the board kept 5.9 GFLOP/s at 55.6 °C at most, and it decodes 1080p video in software at 258 (H.264), 246 (HEVC), 204 (VP9) and 159 (AV1) frames per second.
+**Monitor and image.** Since 0.8.4.1 the Raspberry Pi 5 image shows the desktop on an HDMI monitor at the first boot (the display driver line in `config.txt` now comes after the firmware's auto-detection lines, and LordOS waits up to 30 s for the driver), sets the clock from the network, and ships Chromium and Firefox ESR. Since 0.8.4 the LordOS Pi kernel (`6.18.57-lordos.3-rpi-2712`) also destroys the connections of a blocked app. **Measured on a monitor (LordBench, 0.8.6 in development):** the 0.8.5 image booted with a 1920×1080 60 Hz monitor on either HDMI port reaches the login screen 5.99 s after the kernel starts (systemd: 2.1 s kernel, 4.2 s userspace). With GPU composition (V3D) a window moved by the compositor keeps 59.4 frames per second, with a frame built in 10.9 ms (median) and 13.0 ms (99th percentile) and 1.0 % of frames late; under an all-core load at the lowest priority it falls to 24 frames per second with 96.5 % late, a problem LordBench found: the compositor's cgroup weighed the same as the load's, so the load's low priority did not count. Giving the compositor ten times the CPU weight of an app raised the same test, run without the monitor, from 43–45 to 56–57 frames per second (31–33 % → 7–8 % late) and brought a pointer move to the screen in 22 ms instead of 32 ms (median); with the monitor it was measured only together with the real-time priority below. The compositor's main and paint threads now also run at the lowest real-time priority, which lord-sessiond allows and lord-server drops before it starts anything, so no app inherits it; on VM 116 under load that took late frames from 2.7–2.9 % to 0.28 % and the slowest 1 % of pointer moves from 31–32 to 25 ms, as without load, with the load getting the same CPU time. On the Pi 5 with its monitor the two changes took the loaded test from 24 to 29–30 frames per second and the compositor no longer waits for a CPU, but under the load a frame takes 15–16 ms to build instead of 7, so it misses the 60 Hz refresh; that cause is still being looked for. LordBench's scene had a square meant to turn that stood still, because it was set through a style key the engine lacks; it now turns, which makes the test heavier: with it, that code showed 53–58 frames per second alone and 24–25 under the load. In development for 0.8.6, a dragged window's frame paints only what changed (the changed part of the window's layer and of what is below it), with the same pixels, checked frame by frame against recorded hashes; with that, the same test shows 59.8–60 frames per second alone (99th percentile 11.3–11.6 ms) and 30 under the load, where a frame is built in 12.9 ms (median) instead of about 20. Under the load nearly every frame is still late. A final run of the development build (2026-10-29) measured the two remaining changes. Composing the dragged window on the GPU passes its self-test on the Pi's GPU and gave the CPU's exact pixels in all 138 frames compared, but no measurable gain (30.8–31.6 frames per second under the load, against 30.5–31.1 without it). Painting the next frame while the previous one waits for the flip gave 33–36 frames per second under the load, but a pointer move reached the screen 17 ms later alone (42 instead of 25.5 ms, median) and 29 ms later under the load (78 instead of 49 ms). Both stay in the code and are off by default. With the final defaults the Pi 5 shows 59.9 frames per second alone and still goes from 60 to about 31 (30.5–31.1) under an all-core load. The remaining cost is the GPU's time per frame, which goes from 1.5 ms alone to 14–16 ms under the load, while the clocks and the temperature (36.7–47.2 °C) show no clock or thermal throttling; memory contention between the GPU and the busy cores is the likely cause, not yet proven. The board's under-voltage alarm is present and read 0 with the official power supply. In a 3-minute all-core load with the fan the board kept 5.9 GFLOP/s at 55.6 °C at most, and it decodes 1080p video in software at 258 (H.264), 246 (HEVC), 204 (VP9) and 159 (AV1) frames per second.
### 7.5 Modern PCs
-There are no measurements on real PCs in the repository yet. The ISO is tested on virtual machines (UEFI and BIOS); testing on a real AMD machine from the live USB is planned. LordBench (0.8.6) is designed to measure memory and CPU at idle, boot time, frame times, video and app start in a repeatable way, and community hardware reports (0.8.7) to collect them from real machines (`docs/BENCHMARK.md`). In development for 0.8.6 (unreleased; the latest release is 0.8.5-beta), its first part is built: a sandboxed `lord-bench` helper that measures the CPU, memory, the GPU offscreen, storage and a sustained load, stops near the temperature limit or when the processor throttles, and records the conditions of each run, shown in System Information → Performance as "×N" of reference machines; it also measures software video decoding and the remote desktop's encoders, the desktop's frame times and the time from a pointer move to the screen, alone and under a low-priority load, and boot time over several restarts; it also runs from a terminal (`lordos-sysreport bench`). Also in development, it times LordOS's own interface work with the engine's real code (the layout and paint of a fixed full-HD desktop scene, and the shaping of paragraphs in Latin, Arabic, Devanagari, Thai and Chinese with fonts built into the helper, which opens no files; on the reference virtual machine 37 frames per second on one core and 40 with the paint threads, 619 shaping runs per second on one core and 3,595 on eight), compared with a reference only when it was measured with the same LordOS version, and `lord-bench` checks its own sandbox before any work: six things it must not be able to do (open a local socket or a network connection, run a program, start a process, create a file, read a system file) were all refused on that machine, and a run where one gets through is marked unstable. On a Raspberry Pi it watches the board's firmware during the whole run: the under-voltage alarm, the only flag the LordOS Pi kernel exposes, the firmware's full throttling flags where an older kernel has them, and 80 °C, where the firmware starts slowing the processor down, which stops a peak test as throttled; System Information's Raspberry Pi section reads the same alarm and flags and leaves out what the kernel doesn't show. This was tested on simulated system files, not yet on a real Pi. The references are a virtual machine and a Raspberry Pi 5 (§7.4); hardware video decoding and a real PC reference are not built yet.
+There are no measurements on real PCs in the repository yet. The ISO is tested on virtual machines (UEFI and BIOS); testing on a real AMD machine from the live USB is planned. LordBench (0.8.6) is designed to measure memory and CPU at idle, boot time, frame times, video and app start in a repeatable way, and community hardware reports (0.8.7) to collect them from real machines (`docs/BENCHMARK.md`). In development for 0.8.6 (unreleased; the latest release is 0.8.5-beta), its first part is built: a sandboxed `lord-bench` helper that measures the CPU, memory, the GPU offscreen, storage and a sustained load, stops near the temperature limit or when the processor throttles, and records the conditions of each run, shown in System Information → Performance as "×N" of reference machines; it also measures software video decoding and the remote desktop's encoders, the desktop's frame times and the time from a pointer move to the screen, alone and under a low-priority load, and boot time over several restarts; it also runs from a terminal (`lordos-sysreport bench`). Also in development, it times LordOS's own interface work with the engine's real code (the layout and paint of a fixed full-HD desktop scene, and the shaping of paragraphs in Latin, Arabic, Devanagari, Thai and Chinese with fonts built into the helper, which opens no files; on the reference virtual machine 37 frames per second on one core and 40 with the paint threads, 619 shaping runs per second on one core and 3,595 on eight; on the Raspberry Pi 5, in two quick runs, 39 and 45 frames per second and 630 and 2,520 shaping runs per second on one and four cores), compared with a reference only when it was measured with the same LordOS version, and `lord-bench` checks its own sandbox before any work: six things it must not be able to do (open a local socket or a network connection, run a program, start a process, create a file, read a system file) were all refused on that machine, and a run where one gets through is marked unstable. On a Raspberry Pi it watches the board's firmware during the whole run: the under-voltage alarm, the only flag the LordOS Pi kernel exposes, the firmware's full throttling flags where an older kernel has them, and 80 °C, where the firmware starts slowing the processor down, which stops a peak test as throttled; System Information's Raspberry Pi section reads the same alarm and flags and leaves out what the kernel doesn't show. This was tested on simulated system files and on the Pi 5, where the alarm is present and reads 0 with the official power supply; an actual under-voltage was not provoked. The references are a virtual machine and a Raspberry Pi 5 (§7.4); hardware video decoding and a real PC reference are not built yet.
### Source files
@@ -544,7 +544,7 @@ There are no measurements on real PCs in the repository yet. The ISO is tested o
- The package engine doesn't do i386 multiarch yet, so Steam isn't offered.
- AI apps on a GPU: llama.cpp's Vulkan backend is untested on real AMD, NVIDIA and Intel hardware.
- Dragging a window in 0.8.5-beta: small black squares can show at its rounded corners while it moves, on the monitor and in the remote desktop's frames (fixed for 0.8.6, in development, §7.2).
-- On the Raspberry Pi 5 an app keeping every core busy still halves the desktop's frame rate (30 instead of 60 frames a second in LordBench's test, §7.4). <!-- PI-RESULT: §10.2, if the frame pipeline brings the Pi 5 under load near 60 fps, remove or reword this limitation with the measured number -->
+- On the Raspberry Pi 5 an app keeping every core busy still halves the desktop's frame rate (about 31 instead of 60 frames a second in LordBench's test): the GPU's time per frame grows under the load, and the two changes measured for it in 0.8.6 (in development) gave too little and are off by default (§7.4).
- Legacy BIOS boot: a black rectangle (GRUB's terminal area while it loads the kernel and the initrd) shows for a few seconds between the boot menu and the splash.
- Wayland: no drag and drop, no LordOS input methods inside Linux apps (`text-input`), no `xdg-activation`, explicit sync, tearing control or tablets (§3.4).
- Without a GPU, AV1 video at 60 fps is heavy, since the browser decodes it in software on the same machine.
diff --git a/web/content/paper/paper.es.md b/web/content/paper/paper.es.md
index 26309ae..1ba31b0 100644
--- a/web/content/paper/paper.es.md
+++ b/web/content/paper/paper.es.md
@@ -457,7 +457,7 @@ Todas las cifras de abajo las midió el proyecto y están documentadas en los ar
- **Vblank por software (0.8.5).** Una placa virtual que completa los cambios de imagen al instante (`vmwgfx` de VMware) hacía que el compositor y sus apps dibujaran 500–580 cuadros por segundo en una pantalla de 60 Hz; LordOS ahora lo detecta y marca el ritmo del refresco con una grilla fija: 59,8 cuadros por segundo, p99 de 18,4 ms, ningún cuadro fuera de tiempo (`results/0.8.5~rc1-beta/vmware-fusion`). En la 0.8.5-beta publicada, el Banco de pruebas con su vista 3D en la misma máquina midió 59,83 cuadros por segundo sobre 1.796 cuadros, p99 de 17,9 ms, un cuadro fuera de tiempo, 1.795 presentados (`results/0.8.5-beta/vmware-fusion`). La misma grilla también marca el ritmo de las sesiones sin monitor, así que esperar en milisegundos enteros ya no convierte 60 cuadros por segundo en 57.
- **Arrastrar por el camino de GPU (corrección de la 0.8.5).** Una ventana que se arrastra se pinta desde una capa en caché; en el camino de GPU cada píxel totalmente transparente de esa capa se tomaba por el hueco de una ventana de Linux, y ahora solo los píxeles dentro de una superficie de app. En la 0.8.5-beta todavía podían verse pequeños cuadrados negros en las esquinas redondeadas de una ventana que se arrastra, en los caminos de CPU y de GPU: al restaurar las esquinas, la capa tomaba el píxel guardado como opaco. En la 0.8.6 (en desarrollo) mezcla los dos píxeles con su alfa, así la capa queda transparente fuera de la curva; una prueba compara cada esquina con un repintado completo en los dos caminos (§10.2).
-- **Un cuadro de arrastre más barato (0.8.6, en desarrollo).** El cuadro de una ventana que se arrastra ahora pinta solo la parte de su capa que cambió y solo la parte cambiada de lo que está debajo, con los mismos píxeles: tienen que coincidir 2.417 hashes de cuadros registrados por camino, y el único cambio aprobado deja las esquinas redondeadas bajo la ventana un nivel más cerca de un repintado completo. En el camino de GPU la propia ventana puede componerla la GPU con la aritmética exacta de la CPU, después de una autoprueba de cada combinación de píxeles ("GPU drag"), y el cuadro siguiente puede pintarse mientras el cambio de página anterior está pendiente. Los resultados en la Raspberry Pi 5 están en §7.4.
+- **Un cuadro de arrastre más barato (0.8.6, en desarrollo).** El cuadro de una ventana que se arrastra ahora pinta solo la parte de su capa que cambió y solo la parte cambiada de lo que está debajo, con los mismos píxeles: tienen que coincidir 2.417 hashes de cuadros registrados por camino, y el único cambio aprobado deja las esquinas redondeadas bajo la ventana un nivel más cerca de un repintado completo. En el camino de GPU la propia ventana puede componerla la GPU con la aritmética exacta de la CPU, después de una autoprueba de cada combinación de píxeles ("GPU drag"), y el cuadro siguiente puede pintarse mientras el cambio de página anterior está pendiente; las dos cosas se midieron en la Raspberry Pi 5 y están apagadas por defecto. Los resultados en la Raspberry Pi 5 están en §7.4.
- Arrastrar una ventana en una pantalla de 1280×800 por el camino de CPU: unos 6,7–6,9 ms de trabajo por cuadro, alrededor de 120 cuadros por segundo (VM 118, `docs/DISPLAYS.md`).
- La misma ventana en una pantalla de 2560×1600 al 150 %: unos 5,1 ms por cuadro.
- Video: pintar directamente desde el cuadro decodificado cuando solo cambió un video opaco bajó `lord-server` del 42 % al 13 % de un núcleo para un video 1080p en ventana, y del 92 % al 15 % a pantalla completa (`docs/ROADMAP.md`, multimedia).
@@ -485,11 +485,11 @@ La Raspberry Pi 5 es la única placa soportada. Resultados en una placa real (16
**Ventiladores.** En la Pi 5 dentro de un gabinete de prueba, `lord-fand` mantuvo el ventilador apagado a 50–53 °C durante una carga de 4 hilos (el gabinete de aluminio funciona como disipador), lo llevó al 55 % (4.500 RPM) y a velocidad máxima (7.400 RPM) con curvas de prueba, y restauró la configuración propia del kernel después de `SIGTERM` y de `kill -9` (`docs/FANS.md`).
-**Monitor e imagen.** Desde la 0.8.4.1 la imagen para Raspberry Pi 5 muestra el escritorio en un monitor HDMI en el primer arranque (la línea del driver de pantalla en `config.txt` ahora va después de las líneas de autodetección del firmware, y LordOS espera hasta 30 s al driver), pone la hora desde la red y trae Chromium y Firefox ESR. Desde la 0.8.4 el kernel de LordOS para la Pi (`6.18.57-lordos.3-rpi-2712`) además destruye las conexiones de una app bloqueada. **Medido con monitor (LordBench, 0.8.6 en desarrollo):** la imagen 0.8.5 arrancada con un monitor de 1920×1080 a 60 Hz en cualquiera de los dos puertos HDMI llega a la pantalla de inicio de sesión 5,99 s después de que arranca el kernel (systemd: 2,1 s de kernel y 4,2 s del resto). Con composición por GPU (V3D), una ventana movida por el compositor se mantiene en 59,4 cuadros por segundo, con un cuadro armado en 10,9 ms (mediana) y 13,0 ms (percentil 99) y el 1,0 % de cuadros tarde; con una carga en todos los núcleos a la menor prioridad baja a 24 cuadros por segundo con el 96,5 % tarde, un problema que encontró LordBench: el cgroup del compositor pesaba lo mismo que el de la carga, así que la baja prioridad de la carga no contaba. Darle al compositor diez veces el peso de CPU de una app subió la misma prueba, sin el monitor, de 43–45 a 56–57 cuadros por segundo (31–33 % → 7–8 % tarde) y llevó un movimiento del puntero a la pantalla en 22 ms en vez de 32 ms (mediana); con el monitor solo se midió junto con la prioridad de tiempo real que sigue. Además, el hilo principal del compositor y sus hilos de pintado ahora corren con la menor prioridad de tiempo real, que lord-sessiond permite y lord-server abandona antes de lanzar nada, así que ninguna app la hereda; en la VM 116 bajo carga eso llevó los cuadros tarde de 2,7–2,9 % a 0,28 % y el 1 % más lento de los movimientos del puntero de 31–32 a 25 ms, como sin carga, con la carga recibiendo el mismo tiempo de CPU. En la Pi 5 con su monitor los dos cambios llevaron la prueba con carga de 24 a 29–30 cuadros por segundo y el compositor ya no espera por la CPU, pero con la carga un cuadro tarda 15–16 ms en armarse en vez de 7, así que no llega al refresco de 60 Hz; esa causa todavía se está buscando. La escena de LordBench tenía un cuadrado que debía girar y estaba quieto, porque se le daba una clave de estilo que el motor no tiene; ahora gira, y eso hace la prueba más pesada: con él, ese código daba 53–58 cuadros por segundo sin carga y 24–25 con la carga. En desarrollo para la 0.8.6, el cuadro de una ventana que se arrastra pinta solo lo que cambió (la parte cambiada de la capa de la ventana y de lo que está debajo), con los mismos píxeles, comprobado cuadro por cuadro contra hashes registrados; con eso la misma prueba da 59,8–60 cuadros por segundo sin carga (percentil 99 de 11,3–11,6 ms) y 30 con la carga, donde un cuadro se arma en 12,9 ms (mediana) en vez de unos 20. Con la carga casi todos los cuadros siguen llegando tarde, porque armar el cuadro, el trabajo de la GPU y el cambio de página van uno después del otro y no entran en los 16,7 ms del refresco. Componer en la GPU la ventana que se arrastra se trabó en esa prueba (52 cuadros por segundo sin carga), así que se midió apagado; pintar el cuadro siguiente mientras el anterior espera el cambio de página está construido y todavía no se midió en la placa. <!-- PI-RESULT: §7.4, the Pi 5 with its monitor and the final build: LordBench Desktop impact alone and under load (fps, late %, build p50) with the defaults (GPU drag where its self-test passes, the frame pipeline while frames are heavy), with LORD_GPU_DRAG=0 and with LORD_PIPELINE=0; replace the GPU drag sentence and "not yet measured on the board" with what was measured, and keep the 53–58 / 24–25 baseline --> En 3 minutos de carga en todos los núcleos con el ventilador la placa mantuvo 5,9 GFLOP/s con 55,6 °C como máximo, y decodifica video 1080p por software a 258 (H.264), 246 (HEVC), 204 (VP9) y 159 (AV1) cuadros por segundo.
+**Monitor e imagen.** Desde la 0.8.4.1 la imagen para Raspberry Pi 5 muestra el escritorio en un monitor HDMI en el primer arranque (la línea del driver de pantalla en `config.txt` ahora va después de las líneas de autodetección del firmware, y LordOS espera hasta 30 s al driver), pone la hora desde la red y trae Chromium y Firefox ESR. Desde la 0.8.4 el kernel de LordOS para la Pi (`6.18.57-lordos.3-rpi-2712`) además destruye las conexiones de una app bloqueada. **Medido con monitor (LordBench, 0.8.6 en desarrollo):** la imagen 0.8.5 arrancada con un monitor de 1920×1080 a 60 Hz en cualquiera de los dos puertos HDMI llega a la pantalla de inicio de sesión 5,99 s después de que arranca el kernel (systemd: 2,1 s de kernel y 4,2 s del resto). Con composición por GPU (V3D), una ventana movida por el compositor se mantiene en 59,4 cuadros por segundo, con un cuadro armado en 10,9 ms (mediana) y 13,0 ms (percentil 99) y el 1,0 % de cuadros tarde; con una carga en todos los núcleos a la menor prioridad baja a 24 cuadros por segundo con el 96,5 % tarde, un problema que encontró LordBench: el cgroup del compositor pesaba lo mismo que el de la carga, así que la baja prioridad de la carga no contaba. Darle al compositor diez veces el peso de CPU de una app subió la misma prueba, sin el monitor, de 43–45 a 56–57 cuadros por segundo (31–33 % → 7–8 % tarde) y llevó un movimiento del puntero a la pantalla en 22 ms en vez de 32 ms (mediana); con el monitor solo se midió junto con la prioridad de tiempo real que sigue. Además, el hilo principal del compositor y sus hilos de pintado ahora corren con la menor prioridad de tiempo real, que lord-sessiond permite y lord-server abandona antes de lanzar nada, así que ninguna app la hereda; en la VM 116 bajo carga eso llevó los cuadros tarde de 2,7–2,9 % a 0,28 % y el 1 % más lento de los movimientos del puntero de 31–32 a 25 ms, como sin carga, con la carga recibiendo el mismo tiempo de CPU. En la Pi 5 con su monitor los dos cambios llevaron la prueba con carga de 24 a 29–30 cuadros por segundo y el compositor ya no espera por la CPU, pero con la carga un cuadro tarda 15–16 ms en armarse en vez de 7, así que no llega al refresco de 60 Hz; esa causa todavía se está buscando. La escena de LordBench tenía un cuadrado que debía girar y estaba quieto, porque se le daba una clave de estilo que el motor no tiene; ahora gira, y eso hace la prueba más pesada: con él, ese código daba 53–58 cuadros por segundo sin carga y 24–25 con la carga. En desarrollo para la 0.8.6, el cuadro de una ventana que se arrastra pinta solo lo que cambió (la parte cambiada de la capa de la ventana y de lo que está debajo), con los mismos píxeles, comprobado cuadro por cuadro contra hashes registrados; con eso la misma prueba da 59,8–60 cuadros por segundo sin carga (percentil 99 de 11,3–11,6 ms) y 30 con la carga, donde un cuadro se arma en 12,9 ms (mediana) en vez de unos 20. Con la carga casi todos los cuadros siguen llegando tarde. Una medición final de la versión en desarrollo (2026-10-29) midió los dos cambios que faltaban. Componer en la GPU la ventana que se arrastra pasa su autoprueba en la GPU de la Pi y dio exactamente los píxeles de la CPU en los 138 cuadros comparados, pero sin una ganancia medible (30,8–31,6 cuadros por segundo con la carga, contra 30,5–31,1 sin ella). Pintar el cuadro siguiente mientras el anterior espera el cambio de página dio 33–36 cuadros por segundo con la carga, pero un movimiento del puntero llegó a la pantalla 17 ms más tarde sin carga (42 en vez de 25,5 ms, mediana) y 29 ms más tarde con la carga (78 en vez de 49 ms). Los dos quedan en el código y están apagados por defecto. Con los valores por defecto finales la Pi 5 muestra 59,9 cuadros por segundo sin carga y todavía pasa de 60 a unos 31 (30,5–31,1) con una carga en todos los núcleos. Lo que queda es el tiempo de la GPU por cuadro, que pasa de 1,5 ms sin carga a 14–16 ms con la carga, mientras los relojes y la temperatura (36,7–47,2 °C) no muestran ninguna reducción de frecuencia ni por temperatura; la causa probable es la competencia por la memoria entre la GPU y los núcleos ocupados, todavía no demostrada. La alarma de bajo voltaje de la placa está presente y marcó 0 con la fuente oficial. En 3 minutos de carga en todos los núcleos con el ventilador la placa mantuvo 5,9 GFLOP/s con 55,6 °C como máximo, y decodifica video 1080p por software a 258 (H.264), 246 (HEVC), 204 (VP9) y 159 (AV1) cuadros por segundo.
### 7.5 PC modernas
-Todavía no hay mediciones en PC reales en el repositorio. La ISO se prueba en máquinas virtuales (UEFI y BIOS); está planeado probarla en una máquina AMD real desde el USB live. LordBench (0.8.6) está diseñado para medir de forma repetible la memoria y la CPU en reposo, el tiempo de arranque, los tiempos de cuadro, el video y el inicio de apps, y los informes de hardware de la comunidad (0.8.7), para recolectar esas mediciones de máquinas reales (`docs/BENCHMARK.md`). En desarrollo para la 0.8.6 (sin publicar; la última versión es la 0.8.5-beta), su primera parte ya está construida: un ayudante aislado, `lord-bench`, que mide la CPU, la memoria, la GPU fuera de pantalla, el almacenamiento y una carga sostenida, se detiene cerca del límite de temperatura o cuando el procesador baja la velocidad, y registra las condiciones de cada prueba, que Información del sistema → Rendimiento muestra como «×N» de máquinas de referencia; también mide la decodificación de video por software y los codificadores del escritorio remoto, los tiempos de cuadro del escritorio y el tiempo de un movimiento del puntero hasta la pantalla, solo y bajo una carga de baja prioridad, y el tiempo de arranque en varios reinicios; también corre desde una terminal (`lordos-sysreport bench`). También en desarrollo, mide el trabajo de la propia interfaz de LordOS con el código real del motor (el diseño y dibujo de una escena de escritorio fija en full HD, y la composición tipográfica de párrafos en latín, árabe, devanagari, tailandés y chino con fuentes incluidas en el ayudante, que no abre archivos; en la máquina virtual de referencia 37 cuadros por segundo en un núcleo y 40 con los hilos de dibujo, 619 pasadas de composición por segundo en un núcleo y 3.595 en ocho), comparado con una referencia solo si se midió con la misma versión de LordOS, y `lord-bench` comprueba su propio aislamiento antes de cualquier trabajo: seis cosas que no debe poder hacer (abrir un socket local o una conexión de red, ejecutar un programa, iniciar un proceso, crear un archivo, leer un archivo del sistema) fueron todas rechazadas en esa máquina, y una prueba en la que alguna pase se marca como inestable. En una Raspberry Pi vigila el firmware de la placa durante toda la prueba: la alarma de bajo voltaje, el único indicador que expone el kernel de LordOS para la Pi, los indicadores completos de limitación del firmware donde un kernel más viejo los tiene, y los 80 °C, donde el firmware empieza a bajar la velocidad del procesador, que detienen una prueba de pico como limitada; la sección Raspberry Pi de Información del sistema lee la misma alarma y los mismos indicadores y deja afuera lo que el kernel no muestra. Esto se probó con archivos de sistema simulados, todavía no en una Pi real. Las referencias son una máquina virtual y una Raspberry Pi 5 (§7.4); la decodificación de video por hardware y una referencia de PC real todavía no están construidas.
+Todavía no hay mediciones en PC reales en el repositorio. La ISO se prueba en máquinas virtuales (UEFI y BIOS); está planeado probarla en una máquina AMD real desde el USB live. LordBench (0.8.6) está diseñado para medir de forma repetible la memoria y la CPU en reposo, el tiempo de arranque, los tiempos de cuadro, el video y el inicio de apps, y los informes de hardware de la comunidad (0.8.7), para recolectar esas mediciones de máquinas reales (`docs/BENCHMARK.md`). En desarrollo para la 0.8.6 (sin publicar; la última versión es la 0.8.5-beta), su primera parte ya está construida: un ayudante aislado, `lord-bench`, que mide la CPU, la memoria, la GPU fuera de pantalla, el almacenamiento y una carga sostenida, se detiene cerca del límite de temperatura o cuando el procesador baja la velocidad, y registra las condiciones de cada prueba, que Información del sistema → Rendimiento muestra como «×N» de máquinas de referencia; también mide la decodificación de video por software y los codificadores del escritorio remoto, los tiempos de cuadro del escritorio y el tiempo de un movimiento del puntero hasta la pantalla, solo y bajo una carga de baja prioridad, y el tiempo de arranque en varios reinicios; también corre desde una terminal (`lordos-sysreport bench`). También en desarrollo, mide el trabajo de la propia interfaz de LordOS con el código real del motor (el diseño y dibujo de una escena de escritorio fija en full HD, y la composición tipográfica de párrafos en latín, árabe, devanagari, tailandés y chino con fuentes incluidas en el ayudante, que no abre archivos; en la máquina virtual de referencia 37 cuadros por segundo en un núcleo y 40 con los hilos de dibujo, 619 pasadas de composición por segundo en un núcleo y 3.595 en ocho; en la Raspberry Pi 5, en dos pruebas rápidas, 39 y 45 cuadros por segundo y 630 y 2.520 pasadas de composición por segundo en uno y cuatro núcleos), comparado con una referencia solo si se midió con la misma versión de LordOS, y `lord-bench` comprueba su propio aislamiento antes de cualquier trabajo: seis cosas que no debe poder hacer (abrir un socket local o una conexión de red, ejecutar un programa, iniciar un proceso, crear un archivo, leer un archivo del sistema) fueron todas rechazadas en esa máquina, y una prueba en la que alguna pase se marca como inestable. En una Raspberry Pi vigila el firmware de la placa durante toda la prueba: la alarma de bajo voltaje, el único indicador que expone el kernel de LordOS para la Pi, los indicadores completos de limitación del firmware donde un kernel más viejo los tiene, y los 80 °C, donde el firmware empieza a bajar la velocidad del procesador, que detienen una prueba de pico como limitada; la sección Raspberry Pi de Información del sistema lee la misma alarma y los mismos indicadores y deja afuera lo que el kernel no muestra. Esto se probó con archivos de sistema simulados y en la Pi 5, donde la alarma está presente y marca 0 con la fuente oficial; no se provocó un bajo voltaje real. Las referencias son una máquina virtual y una Raspberry Pi 5 (§7.4); la decodificación de video por hardware y una referencia de PC real todavía no están construidas.
### Archivos fuente
@@ -544,7 +544,7 @@ La 0.8.0 Beta fue el primer lanzamiento público (18 de octubre de 2026); la 0.7
- El motor de paquetes todavía no hace multiarch i386, así que Steam no se ofrece.
- Apps de IA en una GPU: el backend Vulkan de llama.cpp no se probó en hardware AMD, NVIDIA ni Intel real.
- Arrastrar una ventana en la 0.8.5-beta: pueden verse pequeños cuadrados negros en sus esquinas redondeadas mientras se mueve, en el monitor y en los cuadros del escritorio remoto (corregido para la 0.8.6, en desarrollo, §7.2).
-- En la Raspberry Pi 5 una app que ocupa todos los núcleos todavía reduce a la mitad la frecuencia de cuadros del escritorio (30 en vez de 60 cuadros por segundo en la prueba de LordBench, §7.4). <!-- PI-RESULT: §10.2, if the frame pipeline brings the Pi 5 under load near 60 fps, remove or reword this limitation with the measured number -->
+- En la Raspberry Pi 5 una app que ocupa todos los núcleos todavía reduce a la mitad la frecuencia de cuadros del escritorio (unos 31 en vez de 60 cuadros por segundo en la prueba de LordBench): el tiempo de la GPU por cuadro crece con la carga, y los dos cambios medidos para eso en la 0.8.6 (en desarrollo) dieron muy poco y están apagados por defecto (§7.4).
- Arranque con BIOS heredado: un rectángulo negro (el área de terminal de GRUB mientras carga el kernel y el initrd) se ve unos segundos entre el menú de arranque y la pantalla de carga.
- Wayland: sin arrastrar y soltar, sin métodos de entrada de LordOS dentro de apps de Linux (`text-input`), sin `xdg-activation`, sincronización explícita, control de tearing ni tabletas (§3.4).
- Sin GPU, el video AV1 a 60 fps es pesado, porque el navegador lo decodifica por software en la misma máquina.
diff --git a/web/content/paper/paper.pt.md b/web/content/paper/paper.pt.md
index 866dd50..e822f9f 100644
--- a/web/content/paper/paper.pt.md
+++ b/web/content/paper/paper.pt.md
@@ -457,7 +457,7 @@ Todos os números abaixo foram medidos pelo projeto e estão documentados nos ar
- **Vblank por software (0.8.5).** Uma placa virtual que completa as trocas de imagem na hora (`vmwgfx` do VMware) fazia o compositor e seus apps desenharem 500–580 quadros por segundo numa tela de 60 Hz; o LordOS agora detecta isso e marca o ritmo da atualização com uma grade fixa: 59,8 quadros por segundo, p99 de 18,4 ms, nenhum quadro fora do tempo (`results/0.8.5~rc1-beta/vmware-fusion`). Na 0.8.5-beta lançada, o Banco de testes com sua vista 3D na mesma máquina mediu 59,83 quadros por segundo ao longo de 1.796 quadros, p99 de 17,9 ms, um quadro fora do tempo, 1.795 apresentados (`results/0.8.5-beta/vmware-fusion`). A mesma grade também marca o ritmo das sessões sem monitor, então esperar em milissegundos inteiros não transforma mais 60 quadros por segundo em 57.
- **Arrastar pelo caminho da GPU (correção da 0.8.5).** Uma janela arrastada é pintada a partir de uma camada em cache; no caminho da GPU cada pixel totalmente transparente dessa camada era tomado pelo buraco de uma janela Linux, e agora só os pixels dentro de uma superfície de app. Na 0.8.5-beta ainda podiam aparecer pequenos quadrados pretos nos cantos arredondados de uma janela arrastada, nos caminhos da CPU e da GPU: ao restaurar os cantos, a camada tomava o pixel guardado como opaco. Na 0.8.6 (em desenvolvimento) ela mistura os dois pixels com o alfa, então a camada fica transparente fora da curva; um teste compara cada canto com uma repintura completa nos dois caminhos (§10.2).
-- **Um quadro de arrasto mais barato (0.8.6, em desenvolvimento).** O quadro de uma janela arrastada agora pinta só a parte da sua camada que mudou e só a parte alterada do que está embaixo dela, com os mesmos pixels: 2.417 hashes de quadros registrados por caminho têm de bater, e a única mudança aprovada deixa os cantos arredondados sob a janela um nível mais perto de uma repintura completa. No caminho da GPU a própria janela pode ser composta pela GPU com a aritmética exata da CPU, depois de um autoteste de cada combinação de pixels ("GPU drag"), e o quadro seguinte pode ser pintado enquanto a troca de página anterior está pendente. Os resultados no Raspberry Pi 5 estão em §7.4.
+- **Um quadro de arrasto mais barato (0.8.6, em desenvolvimento).** O quadro de uma janela arrastada agora pinta só a parte da sua camada que mudou e só a parte alterada do que está embaixo dela, com os mesmos pixels: 2.417 hashes de quadros registrados por caminho têm de bater, e a única mudança aprovada deixa os cantos arredondados sob a janela um nível mais perto de uma repintura completa. No caminho da GPU a própria janela pode ser composta pela GPU com a aritmética exata da CPU, depois de um autoteste de cada combinação de pixels ("GPU drag"), e o quadro seguinte pode ser pintado enquanto a troca de página anterior está pendente; as duas coisas foram medidas no Raspberry Pi 5 e estão desligadas por padrão. Os resultados no Raspberry Pi 5 estão em §7.4.
- Arrastar uma janela numa tela de 1280×800 pelo caminho da CPU: cerca de 6,7–6,9 ms de trabalho por quadro, por volta de 120 quadros por segundo (VM 118, `docs/DISPLAYS.md`).
- A mesma janela numa tela de 2560×1600 a 150 %: cerca de 5,1 ms por quadro.
- Vídeo: pintar direto do quadro decodificado quando só um vídeo opaco mudou levou o `lord-server` de 42 % para 13 % de um núcleo com um vídeo 1080p em janela, e de 92 % para 15 % em tela cheia (`docs/ROADMAP.md`, mídia).
@@ -485,11 +485,11 @@ O Raspberry Pi 5 é a única placa suportada. Resultados numa placa real (16 GB,
**Ventoinhas.** No Pi 5 num gabinete de teste, o `lord-fand` manteve a ventoinha desligada a 50–53 °C durante uma carga de 4 threads (o gabinete de alumínio funciona como dissipador), a levou a 55 % (4.500 RPM) e à velocidade máxima (7.400 RPM) com curvas de teste e restaurou as configurações do próprio kernel depois de `SIGTERM` e `kill -9` (`docs/FANS.md`).
-**Monitor e imagem.** Desde a 0.8.4.1 a imagem do Raspberry Pi 5 mostra o desktop num monitor HDMI no primeiro boot (a linha do driver de vídeo no `config.txt` agora vem depois das linhas de autodetecção do firmware, e o LordOS espera até 30 s pelo driver), acerta o relógio pela rede e traz Chromium e Firefox ESR. Desde a 0.8.4 o kernel do LordOS para o Pi (`6.18.57-lordos.3-rpi-2712`) também destrói as conexões de um app bloqueado. **Medido com monitor (LordBench, 0.8.6 em desenvolvimento):** a imagem 0.8.5 inicializada com um monitor de 1920×1080 a 60 Hz em qualquer uma das duas portas HDMI chega à tela de login 5,99 s depois que o kernel inicia (systemd: 2,1 s de kernel e 4,2 s do resto). Com composição na GPU (V3D), uma janela movida pelo compositor se mantém em 59,4 quadros por segundo, com um quadro montado em 10,9 ms (mediana) e 13,0 ms (percentil 99) e 1,0 % dos quadros atrasados; com uma carga em todos os núcleos na menor prioridade cai para 24 quadros por segundo com 96,5 % atrasados, um problema que o LordBench encontrou: o cgroup do compositor pesava o mesmo que o da carga, então a baixa prioridade da carga não contava. Dar ao compositor dez vezes o peso de CPU de um app elevou o mesmo teste, sem o monitor, de 43–45 para 56–57 quadros por segundo (31–33 % → 7–8 % atrasados) e levou um movimento do ponteiro à tela em 22 ms em vez de 32 ms (mediana); com o monitor só foi medido junto com a prioridade de tempo real a seguir. Além disso, a thread principal do compositor e suas threads de pintura agora rodam com a menor prioridade de tempo real, que o lord-sessiond permite e o lord-server abandona antes de iniciar qualquer coisa, então nenhum app a herda; na VM 116 sob carga isso levou os quadros atrasados de 2,7–2,9 % para 0,28 % e o 1 % mais lento dos movimentos do ponteiro de 31–32 para 25 ms, como sem carga, com a carga recebendo o mesmo tempo de CPU. No Pi 5 com seu monitor as duas mudanças levaram o teste com carga de 24 para 29–30 quadros por segundo e o compositor não espera mais pela CPU, mas com a carga um quadro leva 15–16 ms para ser montado em vez de 7, então não alcança a atualização de 60 Hz; essa causa ainda está sendo procurada. A cena do LordBench tinha um quadrado que devia girar e ficava parado, porque recebia uma chave de estilo que o motor não tem; agora ele gira, e isso deixa o teste mais pesado: com ele, esse código dava 53–58 quadros por segundo sem carga e 24–25 com a carga. Em desenvolvimento para a 0.8.6, o quadro de uma janela arrastada pinta só o que mudou (a parte alterada da camada da janela e do que está embaixo dela), com os mesmos pixels, conferido quadro a quadro contra hashes registrados; com isso o mesmo teste dá 59,8–60 quadros por segundo sem carga (percentil 99 de 11,3–11,6 ms) e 30 com a carga, onde um quadro é montado em 12,9 ms (mediana) em vez de cerca de 20. Com a carga quase todos os quadros continuam atrasados, porque montar o quadro, o trabalho da GPU e a troca de página vêm um depois do outro e não cabem nos 16,7 ms da atualização. Compor na GPU a janela arrastada travou nesse teste (52 quadros por segundo sem carga), então foi medido desligado; pintar o quadro seguinte enquanto o anterior espera a troca de página está pronto e ainda não foi medido na placa. <!-- PI-RESULT: §7.4, the Pi 5 with its monitor and the final build: LordBench Desktop impact alone and under load (fps, late %, build p50) with the defaults (GPU drag where its self-test passes, the frame pipeline while frames are heavy), with LORD_GPU_DRAG=0 and with LORD_PIPELINE=0; replace the GPU drag sentence and "not yet measured on the board" with what was measured, and keep the 53–58 / 24–25 baseline --> Em 3 minutos de carga em todos os núcleos com o ventilador a placa manteve 5,9 GFLOP/s com 55,6 °C no máximo, e decodifica vídeo 1080p por software a 258 (H.264), 246 (HEVC), 204 (VP9) e 159 (AV1) quadros por segundo.
+**Monitor e imagem.** Desde a 0.8.4.1 a imagem do Raspberry Pi 5 mostra o desktop num monitor HDMI no primeiro boot (a linha do driver de vídeo no `config.txt` agora vem depois das linhas de autodetecção do firmware, e o LordOS espera até 30 s pelo driver), acerta o relógio pela rede e traz Chromium e Firefox ESR. Desde a 0.8.4 o kernel do LordOS para o Pi (`6.18.57-lordos.3-rpi-2712`) também destrói as conexões de um app bloqueado. **Medido com monitor (LordBench, 0.8.6 em desenvolvimento):** a imagem 0.8.5 inicializada com um monitor de 1920×1080 a 60 Hz em qualquer uma das duas portas HDMI chega à tela de login 5,99 s depois que o kernel inicia (systemd: 2,1 s de kernel e 4,2 s do resto). Com composição na GPU (V3D), uma janela movida pelo compositor se mantém em 59,4 quadros por segundo, com um quadro montado em 10,9 ms (mediana) e 13,0 ms (percentil 99) e 1,0 % dos quadros atrasados; com uma carga em todos os núcleos na menor prioridade cai para 24 quadros por segundo com 96,5 % atrasados, um problema que o LordBench encontrou: o cgroup do compositor pesava o mesmo que o da carga, então a baixa prioridade da carga não contava. Dar ao compositor dez vezes o peso de CPU de um app elevou o mesmo teste, sem o monitor, de 43–45 para 56–57 quadros por segundo (31–33 % → 7–8 % atrasados) e levou um movimento do ponteiro à tela em 22 ms em vez de 32 ms (mediana); com o monitor só foi medido junto com a prioridade de tempo real a seguir. Além disso, a thread principal do compositor e suas threads de pintura agora rodam com a menor prioridade de tempo real, que o lord-sessiond permite e o lord-server abandona antes de iniciar qualquer coisa, então nenhum app a herda; na VM 116 sob carga isso levou os quadros atrasados de 2,7–2,9 % para 0,28 % e o 1 % mais lento dos movimentos do ponteiro de 31–32 para 25 ms, como sem carga, com a carga recebendo o mesmo tempo de CPU. No Pi 5 com seu monitor as duas mudanças levaram o teste com carga de 24 para 29–30 quadros por segundo e o compositor não espera mais pela CPU, mas com a carga um quadro leva 15–16 ms para ser montado em vez de 7, então não alcança a atualização de 60 Hz; essa causa ainda está sendo procurada. A cena do LordBench tinha um quadrado que devia girar e ficava parado, porque recebia uma chave de estilo que o motor não tem; agora ele gira, e isso deixa o teste mais pesado: com ele, esse código dava 53–58 quadros por segundo sem carga e 24–25 com a carga. Em desenvolvimento para a 0.8.6, o quadro de uma janela arrastada pinta só o que mudou (a parte alterada da camada da janela e do que está embaixo dela), com os mesmos pixels, conferido quadro a quadro contra hashes registrados; com isso o mesmo teste dá 59,8–60 quadros por segundo sem carga (percentil 99 de 11,3–11,6 ms) e 30 com a carga, onde um quadro é montado em 12,9 ms (mediana) em vez de cerca de 20. Com a carga quase todos os quadros continuam atrasados. Uma medição final da versão em desenvolvimento (2026-10-29) mediu as duas mudanças que faltavam. Compor na GPU a janela arrastada passa no seu autoteste na GPU do Pi e deu exatamente os pixels da CPU nos 138 quadros comparados, mas sem ganho mensurável (30,8–31,6 quadros por segundo com a carga, contra 30,5–31,1 sem ela). Pintar o quadro seguinte enquanto o anterior espera a troca de página deu 33–36 quadros por segundo com a carga, mas um movimento do ponteiro chegou à tela 17 ms mais tarde sem carga (42 em vez de 25,5 ms, mediana) e 29 ms mais tarde com a carga (78 em vez de 49 ms). As duas ficam no código e estão desligadas por padrão. Com os padrões finais o Pi 5 mostra 59,9 quadros por segundo sem carga e ainda passa de 60 para cerca de 31 (30,5–31,1) com uma carga em todos os núcleos. O que resta é o tempo da GPU por quadro, que passa de 1,5 ms sem carga para 14–16 ms com a carga, enquanto os relógios e a temperatura (36,7–47,2 °C) não mostram nenhuma redução de frequência nem por temperatura; a causa provável é a disputa pela memória entre a GPU e os núcleos ocupados, ainda não comprovada. O alarme de subtensão da placa está presente e marcou 0 com a fonte oficial. Em 3 minutos de carga em todos os núcleos com o ventilador a placa manteve 5,9 GFLOP/s com 55,6 °C no máximo, e decodifica vídeo 1080p por software a 258 (H.264), 246 (HEVC), 204 (VP9) e 159 (AV1) quadros por segundo.
### 7.5 PCs modernos
-Ainda não há medições em PCs reais no repositório. A ISO é testada em máquinas virtuais (UEFI e BIOS); está planejado testá-la numa máquina AMD real a partir do pendrive live. O LordBench (0.8.6) foi projetado para medir de forma repetível memória e CPU em repouso, tempo de boot, tempos de quadro, vídeo e abertura de apps, e os relatórios de hardware da comunidade (0.8.7), para coletar essas medições de máquinas reais (`docs/BENCHMARK.md`). Em desenvolvimento para a 0.8.6 (não publicada; a última versão é a 0.8.5-beta), sua primeira parte já está construída: um auxiliar isolado, `lord-bench`, que mede a CPU, a memória, a GPU fora da tela, o armazenamento e uma carga contínua, para perto do limite de temperatura ou quando o processador reduz a velocidade, e registra as condições de cada teste, que Informações do Sistema → Desempenho mostra como «×N» de máquinas de referência; também mede a decodificação de vídeo por software e os codificadores da área de trabalho remota, os tempos de quadro do desktop e o tempo de um movimento do ponteiro até a tela, sozinho e sob uma carga de baixa prioridade, e o tempo de boot em várias reinicializações; também roda a partir de um terminal (`lordos-sysreport bench`). Também em desenvolvimento, mede o trabalho da própria interface do LordOS com o código real do motor (o layout e o desenho de uma cena de desktop fixa em full HD, e a composição tipográfica de parágrafos em latim, árabe, devanágari, tailandês e chinês com fontes embutidas no auxiliar, que não abre arquivos; na máquina virtual de referência 37 quadros por segundo em um núcleo e 40 com as threads de desenho, 619 passagens de composição por segundo em um núcleo e 3.595 em oito), comparado com uma referência só quando medido com a mesma versão do LordOS, e o `lord-bench` verifica o próprio isolamento antes de qualquer trabalho: seis coisas que não deve conseguir fazer (abrir um socket local ou uma conexão de rede, executar um programa, iniciar um processo, criar um arquivo, ler um arquivo do sistema) foram todas recusadas nessa máquina, e um teste em que alguma passe é marcado como instável. Num Raspberry Pi ele vigia o firmware da placa durante todo o teste: o alarme de subtensão, o único indicador que o kernel do LordOS para o Pi expõe, os indicadores completos de limitação do firmware onde um kernel mais antigo os tem, e os 80 °C, onde o firmware começa a reduzir a velocidade do processador, que param um teste de pico como limitado; a seção Raspberry Pi de Informações do sistema lê o mesmo alarme e os mesmos indicadores e deixa de fora o que o kernel não mostra. Isso foi testado com arquivos de sistema simulados, ainda não num Pi real. As referências são uma máquina virtual e um Raspberry Pi 5 (§7.4); a decodificação de vídeo por hardware e uma referência de PC real ainda não estão construídas.
+Ainda não há medições em PCs reais no repositório. A ISO é testada em máquinas virtuais (UEFI e BIOS); está planejado testá-la numa máquina AMD real a partir do pendrive live. O LordBench (0.8.6) foi projetado para medir de forma repetível memória e CPU em repouso, tempo de boot, tempos de quadro, vídeo e abertura de apps, e os relatórios de hardware da comunidade (0.8.7), para coletar essas medições de máquinas reais (`docs/BENCHMARK.md`). Em desenvolvimento para a 0.8.6 (não publicada; a última versão é a 0.8.5-beta), sua primeira parte já está construída: um auxiliar isolado, `lord-bench`, que mede a CPU, a memória, a GPU fora da tela, o armazenamento e uma carga contínua, para perto do limite de temperatura ou quando o processador reduz a velocidade, e registra as condições de cada teste, que Informações do Sistema → Desempenho mostra como «×N» de máquinas de referência; também mede a decodificação de vídeo por software e os codificadores da área de trabalho remota, os tempos de quadro do desktop e o tempo de um movimento do ponteiro até a tela, sozinho e sob uma carga de baixa prioridade, e o tempo de boot em várias reinicializações; também roda a partir de um terminal (`lordos-sysreport bench`). Também em desenvolvimento, mede o trabalho da própria interface do LordOS com o código real do motor (o layout e o desenho de uma cena de desktop fixa em full HD, e a composição tipográfica de parágrafos em latim, árabe, devanágari, tailandês e chinês com fontes embutidas no auxiliar, que não abre arquivos; na máquina virtual de referência 37 quadros por segundo em um núcleo e 40 com as threads de desenho, 619 passagens de composição por segundo em um núcleo e 3.595 em oito; no Raspberry Pi 5, em dois testes rápidos, 39 e 45 quadros por segundo e 630 e 2.520 passagens de composição por segundo em um e quatro núcleos), comparado com uma referência só quando medido com a mesma versão do LordOS, e o `lord-bench` verifica o próprio isolamento antes de qualquer trabalho: seis coisas que não deve conseguir fazer (abrir um socket local ou uma conexão de rede, executar um programa, iniciar um processo, criar um arquivo, ler um arquivo do sistema) foram todas recusadas nessa máquina, e um teste em que alguma passe é marcado como instável. Num Raspberry Pi ele vigia o firmware da placa durante todo o teste: o alarme de subtensão, o único indicador que o kernel do LordOS para o Pi expõe, os indicadores completos de limitação do firmware onde um kernel mais antigo os tem, e os 80 °C, onde o firmware começa a reduzir a velocidade do processador, que param um teste de pico como limitado; a seção Raspberry Pi de Informações do sistema lê o mesmo alarme e os mesmos indicadores e deixa de fora o que o kernel não mostra. Isso foi testado com arquivos de sistema simulados e no Pi 5, onde o alarme está presente e marca 0 com a fonte oficial; uma subtensão real não foi provocada. As referências são uma máquina virtual e um Raspberry Pi 5 (§7.4); a decodificação de vídeo por hardware e uma referência de PC real ainda não estão construídas.
### Arquivos-fonte
@@ -544,7 +544,7 @@ A 0.8.0 Beta foi o primeiro lançamento público (18 de outubro de 2026); a 0.7.
- O motor de pacotes ainda não faz multiarch i386, então o Steam não é oferecido.
- Apps de IA numa GPU: o backend Vulkan do llama.cpp não foi testado em hardware AMD, NVIDIA e Intel real.
- Arrastar uma janela na 0.8.5-beta: podem aparecer pequenos quadrados pretos nos seus cantos arredondados enquanto ela se move, no monitor e nos quadros da área de trabalho remota (corrigido para a 0.8.6, em desenvolvimento, §7.2).
-- No Raspberry Pi 5 um app que ocupa todos os núcleos ainda reduz pela metade a taxa de quadros do desktop (30 em vez de 60 quadros por segundo no teste do LordBench, §7.4). <!-- PI-RESULT: §10.2, if the frame pipeline brings the Pi 5 under load near 60 fps, remove or reword this limitation with the measured number -->
+- No Raspberry Pi 5 um app que ocupa todos os núcleos ainda reduz pela metade a taxa de quadros do desktop (cerca de 31 em vez de 60 quadros por segundo no teste do LordBench): o tempo da GPU por quadro cresce com a carga, e as duas mudanças medidas para isso na 0.8.6 (em desenvolvimento) deram muito pouco e estão desligadas por padrão (§7.4).
- Boot com BIOS legada: um retângulo preto (a área de terminal do GRUB enquanto ele carrega o kernel e o initrd) aparece por alguns segundos entre o menu de boot e a tela de abertura.
- Wayland: sem arrastar e soltar, sem métodos de entrada do LordOS dentro dos apps Linux (`text-input`), sem `xdg-activation`, sincronização explícita, controle de tearing ou mesas digitalizadoras (§3.4).
- Sem GPU, vídeo AV1 a 60 fps é pesado, já que o navegador o decodifica por software na mesma máquina.