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.

Docs for merging perf-frame into main: CHANGELOG [Unreleased] regrouped on main's latest text (summary with the Pi 5 numbers so far, steps 0-11, step 9's corners, GPU drag with its Pi 5 stall, uploads in slices, the paint pool rule, the frame pipeline and style_warn under Changed; the phase timing under Added; the four fixes under Fixed); BENCHMARK (the square turns, "The drag frame's cost" with the Pi 5 table, the pipeline, frame phases, what to run next), GPU (Pi 5 GPU drag result, uploads with the pipeline, pending), WINDOWS (corner restore fix, goldens rewritten twice, Pi numbers), FANS (the fans turn), ROADMAP and PAPER-VALIDATION (done items ticked, Pi run and GPU drag default open), THIRD_PARTY (the QuickJS JS_GetMallocSize patch as a table row), the paper (en/es/pt: corners fixed in development, a cheaper drag frame, the Pi 5 frame numbers, a busy app still halves the Pi frame rate), the FAQ and A desktop of its own (en/es/pt); PI-RESULT HTML comments where the final Pi 5 numbers go, and the site's Markdown renderer drops HTML comments

Federico Pereirab4ee6f3ff358
diff --git a/CHANGELOG.md b/CHANGELOG.md
index d39585b..be0c38b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -12,6 +12,14 @@ of the matching [GitHub release](https://github.com/lordbasex/LordOS/releases),
### Release
+- **Docs for the frame-cost work** (2026-10-29, branch `perf-frame`): `FANS.md`, `BENCHMARK.md`, `WINDOWS.md`,
+ `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
+ 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
engine lacks; fixed in development), and `RASPBERRY.md` records that frame rates on the Pi 5's monitor were measured
by LordBench (two monitors and 4K still not).
@@ -188,6 +196,7 @@ of the matching [GitHub release](https://github.com/lordbasex/LordOS/releases),
firewall and restrictions see it as itself, `flatpak run` arguments built in C, per-user installs through a closed
set of commands in their own network scope with Flathub's key pinned, and the exceptions to `AGENTS.md` the
maintainer has to approve before any code.
+
- **A pixel-exact check for the dragged window's frames** (in development for 0.8.6, the groundwork for making a drag
frame cheaper on the Raspberry Pi; `docs/WINDOWS.md`, "Checking it"). Tests and debugging only: no frame changes.
- **`test_drag_exact`** in `build/engine-test` (`make -C server test`): LordBench's desktop scene (a 760×480 rounded
@@ -199,8 +208,9 @@ of the matching [GitHub release](https://github.com/lordbasex/LordOS/releases),
CPU path and on the GPU path's canvas (`gpu_active()` on), and compared with `tests/drag_golden_cpu.txt` and
`tests/drag_golden_gpu.txt`, written from the current code (x86_64; `make drag-golden` writes another
architecture's): any change to a frame fails. The test also prints how many pixels differ from a full repaint:
- today at most 2,265 per frame on the CPU path, with black pixels at the dragged window's rounded top corners, and
- 70,940 on the GPU path, one level darker in the window's shadow. About 11 s on VM 116.
+ when it was added, at most 2,265 per frame on the CPU path, with black pixels at the dragged window's rounded top
+ corners, and 70,940 on the GPU path, one level darker in the window's shadow (248 and 70,864 after the two corner
+ changes below). About 11 s on VM 116.
- **Three more runs** (the test's cases a reviewer found missing): `neg`, the window starting at (−200, −120) and
moving 6 px right and 4 px down a frame, so its left edge crosses x = 0 and its top y = 0 while the square turns;
`remove`, a badge inside the window removed (`node_detach`) at frame 35, after frames that only copy the layer
@@ -221,13 +231,68 @@ of the matching [GitHub release](https://github.com/lordbasex/LordOS/releases),
- The drag line in `session.log` now says how many of the layer's renders were only a part of it
(`paint_layer_parts`). `lord.setStyle`'s decision of what to place or repaint moved to `node_restyled`
(`ui/node.c`), unchanged, so the test drives the same C path.
+- **LordBench: where a frame's time goes, measured per frame** (0.8.6, in development; `docs/BENCHMARK.md`, "Frame
+ phases"). On the Pi 5 with its monitor a loaded frame is built in about 13 ms and still the monitor shows 30 frames a
+ second, 98 % of them late: the time outside the "build" number (JS before the frame, the GPU's own work, the wait
+ for the vblank) was not measured. lord-server now records, for every frame the main display shows, while
+ LordBench records or a scripted move runs (`bench/lbframes.c`, filled only by `main.c` and `gpu.c`; nothing comes
+ from a helper, and `lb_msg_valid` is unchanged since no new result id exists):
+ - the flip event to lord-server running (`wake`), that wake to `render()` (input, LordBench's scripted step, JS),
+ `render()` itself, its layout and paint, the UI texture's upload (time and pixels), GPU drag's texture uploads (time,
+ pixels, whether one was whole), `eglSwapBuffers`, the framebuffer and page flip ioctl, the GPU's finish time
+ after the flip was queued, the wait to the vblank, and wake to flip;
+ - the GPU's finish time is a native fence taken after `eglSwapBuffers` (`EGL_ANDROID_native_fence_sync`) and read
+ once at the frame's flip with `SYNC_IOC_FILE_INFO` (the sync file's signal time): one ioctl a frame, no wait, no
+ polling, and nothing at all while not recording; without the extension it is "unknown"; a frame scanned out
+ straight (a fullscreen app's buffer) has no upload, swap or GPU time of its own, so it records none and drops a
+ fence left from before instead of reporting the last composed frame's;
+ - each frame against the first vblank after it started: on time (shown within half a period of it), CPU-late
+ (the flip was queued after that vblank), GPU-late (queued before it, the GPU finished after it) or other;
+ - per frame whether the paint threads were on, whether GPU drag composed it or why not (each refusal and, for `layer`,
+ its cause: `invalid`, `rendering`, `holes`, `surfaces`, `premul`, `opacity`, `part` and the rest, `GDRAG_L_*` in
+ `ui/ui.h`), GPU drag's whole uploads and their pixels, and frames not shown (`gpu_frame_ex`'s -2).
+ LordBench's desktop result has them as `frames.phases.alone` and `frames.phases.load` (p50 and p99 in ms, and
+ counts), and the session log gets `lordbench: desktop alone|under load: phases, …`; the `drag (scripted): …` line
+ ends with the same text, and its GPU drag part now lists `… catching up` and the layer's causes. Without a monitor the
+ frame's end is its presentation, on the pacing grid. The System Information page is unchanged (it does not show
+ them). Checked on VM 116: `lordbench-test` (1,192 ok) feeds known frames and checks each class, percentile and
+ count, the text and a short buffer; and a desktop run in an isolated headless session of the worktree's
+ lord-server (a test theme moving one window with `lord.wm.script`, CPU composition, one viewer on its
+ `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 -->
### Changed
+- **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
+ LordBench's turning square, measured together on the Raspberry Pi 5 with its 1920×1080 60 Hz monitor (GPU
+ composition, the session with the weight and the real-time priority, LordBench → Desktop impact, 2026-10-28); the
+ uploads in slices, the paint pool rule, the phase timing and the frame pipeline came after these runs:
+ - before this work, with the square turning (three runs): alone 53.2–58.1 fps (build p99 15.7–16.5 ms, 3.1–12.8 %
+ late), under load 23.6–25.1 fps (build p50 19.8–20.3 ms, 100 % late);
+ - with it and `LORD_GPU_DRAG=0` (two runs): alone 59.8–60.0 fps (build p99 11.3–11.6 ms, 0–0.3 % late), under load
+ 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 -->
+ - 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;
+ `lordbench-test`: 1,197 ok. The codename "G0" of the work became "GPU drag" everywhere (`LORD_GPU_DRAG`,
+ `gdrag_*`, LordBench's `gpuDrag` keys).
- **Less work in a dragged window's frame, same pixels** (in development for 0.8.6; the first steps of making a
drag frame cheaper on the Raspberry Pi). Every frame of `test_drag_exact` keeps its golden hash on the CPU and GPU
- paths (VM 116, x86_64) through these steps; the one approved pixel change, and the golden hashes written again for
- it, is the next entry. The time saved has not been measured yet.
+ paths (VM 116, x86_64) through these steps. The golden hashes were written again twice, each time after a
+ pixel-by-pixel comparison with the code before: for the approved corner change of step 9 (its own entry below) and
+ for the black-corner fix (Fixed). What the steps save was measured on the Pi 5 only all together (the first entry
+ of this section).
- **No clear under the copy of what is below the window:** `paint_root_clear` (`ui/paint.c`) replaces
`canvas_clear` + `paint_root` in `main.c`, `app/appclient.c` and `engine-test`, and skips the clear when the drag
layer's copy of what is below (`below_copy`) is about to write every pixel of the same rectangle. That copy was
@@ -309,7 +374,7 @@ of the matching [GitHub release](https://github.com/lordbasex/LordOS/releases),
them, reorders and removals) over 8 seeds × 300 renders, with styles kept as the same object, copied, changed in
place, reordered, partly undefined, as arrays, with NaN, −0, overrides and transforms. The bundle with the skip and
the same bundle with it turned off send identical `lord.*` call sequences and end with identical styles (72,322
- lines; 31,498 of 53,311 `applyProps` calls skipped; on the Mac). Breaking the skip on purpose fails it: without
+ lines; 31,498 of 53,311 `applyProps` calls skipped; on the development machine, not VM 116). Breaking the skip on purpose fails it: without
the NaN rule all 8 seeds differ; in scratch runs, comparing keys without their order 6 of 6 seeds and comparing
the props' object instead of a copy 3 of 3. The Performance view rendered with a scripted run (waiting, three
steps, a mode change, cancelled) gives the same native call log with 001633b's view and this one, with 146
@@ -362,236 +427,9 @@ of the matching [GitHub release](https://github.com/lordbasex/LordOS/releases),
Dock lies in its reach outside the box), so it stays as the safe side. The differential harnesses against
001633b's six files (3,390, 3,874 and 5,084 frame hashes) are identical. `make -C server test`: 23 passed.
- Not done: skipping the copy under the window's opaque middle (it would have to know, before the layer is
- painted this frame, that the layer stays opaque there and that no ancestor's rounded corner reads it). The time
- saved has not been measured yet.
- - **The dragged window composited on the GPU, with the CPU's pixels ("GPU drag", step 10, approved by the maintainer on
- 2026-10-28; `ui/paint.c`, `gpu/gpu.c`, `main.c`; `docs/GPU.md`, "The dragged window on the GPU").** On the GPU
- path a frame that uses the copy of what is below the window paints only the strips of its damaged box around
- the window's rectangle W; the GPU writes W itself, from two textures of its own (the layer and the copy of what
- is below), with one shader that does `blit_row`'s integer arithmetic (k = 256, `over_alpha`) in 24-bit floats,
- where every value is an integer below 2^24 and every scaling a power of two, so the pixels are the CPU's bit for
- bit. The textures get only what changed since the GPU last had them (the layer's part, the copy's partial
- rebuilds), so the per-frame upload of the old and new window box (2.2–2.6 MB on the Pi) becomes the strips and
- the layer's part.
- - **When:** only after `below_ready` decided to use the copy (its decisions are unchanged), on the display that
- owns the layer, one damaged box, no rotation and no fullscreen app; the layer valid and painted as it is (the
- same opacity, no full render pending, no app window in it, no pixel with a colour above its alpha:
- `layer.premul_bad`, checked where `layer_holes` already walks it); W is the blit cut by the ancestors' clips
- and the box; no ancestor paints over W afterwards (`below_ancestors_ok`); no app window of layer 0 is drawn
- into W (`wl_draws_meet`); the paint order around the window is known and no node painted after it that paints
- anything meets the box (`damage_walk` notes them, grown by a backdrop blur's reach and a transform's edge).
- Anything that changes while the strips are painted (the layer rendered again elsewhere, an app window) paints
- W on the CPU in the same frame. Otherwise the frame is painted as before.
- - **The GPU side** is off unless it proves itself: a `highp` fragment shader with at least 24-bit floats
- (`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
- 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
- textures if they are still that display's, else paints W on the CPU; direct scanout, a failed frame or the GPU
- going away paint it again. A frame whose quad cannot be drawn (a failed upload, GPU drag turned off) is not shown
- at all (`gpu_frame_ex` returns -2): the display keeps the frame before and the next one paints W on the CPU. `LORD_PAINT_VERIFY` leaves W out on GPU drag frames (`LORD_GPU_VERIFY` checks it). The
- `drag: …` and `drag (scripted): …` lines end with `GPU drag: N of M frames (Q quads), strips … Mpx, uploaded below …
- Mpx, layer … Mpx (not: … layer, … clip, … ancestor, … app, … after, … post)`.
- - Checked on VM 116 (x86_64): `canvas-test` compares GPU drag's shader written in C (`canvas_gdrag_model`) with
- `blit_row_c` and the SIMD row over all 8,421,376 valid (alpha, colour, destination) combinations, every alpha
- pair, and 200,000 random pixels: 0 differ (NEON not run: no ARM machine was used). `engine-test` has a third
- path, `gpu-drag`: the GPU path with GPU drag and a stub GPU that keeps the UI texture, the two textures (only their dirty
- rectangles) and `main.c`'s bookkeeping, and writes W with `canvas_gdrag_model`; all 2,417 frames equal
- `drag_golden_gpu.txt`, 250 of the 1,856 frames that use the copy are composited this way (refused: 436 layer,
- 287 app, 883 after: the big scene's window is mostly near the menu bar or the Dock). Four runs without goldens
- are compared frame by frame with the GPU path: a 30-frame pause with no damage (54 of 61 GPU drag), two displays side
- by side (150 of 240), the window over an app window below (5 of 180), and the window against a rounded,
- bordered container's corner (15 of 90; 44 refused for the ancestor); the single-display ones as the GPU shows
- them (the app windows under the UI texture, W written over both). Taking out the after-node, app-window or
- ancestor check fails the test; the layer's own checks (app holes, invalid pixels) are not reached by these
- scenes. `make test`: 23 passed, 0 failed, 13 skipped; `engine-test`: 3,688 checks, 0 failures. With GPU=0 the
- build has no warnings.
- - On VM 116 at runtime (llvmpipe forced with `LORD_GPU=1`, an isolated session lent the card by
- `tests/seat_cycle.c`, a test scene moved by `lord.wm.script`): the self-test of that time (tiles only, in the
- first drag frame) passes (75–113 ms); with
- `LORD_GPU_VERIFY=1`, 1,481 of 1,483 frames were GPU drag and 0 pixels differed in any; across 4 GPU context
- re-creations during the move, 1,328 GPU drag frames, 0 differ; with `LORD_PAINT_VERIFY=16`, 0 pixels differ from a
- full repaint outside W in 92 checks. Layout and paint of a drag frame: 0.29–0.35 ms with GPU drag, 0.92 ms without
- (llvmpipe's own composition dominates the rest, so this says nothing yet about the Pi). `tests/gpu_cycle.sh` 10
- cycles: 38 fds and 226.6–227.6 MB throughout. A real screenshot of GPU drag frames was taken (seat-cycle's snapshot).
- Not measured yet: the Pi 5 (V3D), where the self-test and `LORD_GPU_VERIFY` must pass before the gain is
- claimed.
- - **With the real desktop GPU drag never composed a frame, fixed:** the list of nodes painted after the window
- held 128 boxes and refused every frame once it was full, and LordOS's menu bar and Dock alone fill it
- (`drag: … GPU drag: 0 of 250 frames … 248 after`). The list now grows as needed (up to 65,536 boxes, then the
- frame is refused as before) and skips a box inside the one noted just before it (an icon inside its bar:
- it meets the damaged box only if the bar does), so the menu bar and the Dock are 2 boxes. The decision is
- the same for every frame that fit before. `engine-test`'s `pause` run now has 300 more nodes painted after
- the window, each in its own box: with the old 128-box list it fails (`GPU drag composed 0 of 61`), with this one
- 54 of 61 frames, the same as the GPU path frame by frame.
- - Checked again on VM 116 with the default theme (an isolated 1280 × 800 session lent the card by
- `seat-cycle`, llvmpipe, driven over the remote desktop socket; real screenshots with QMP `screendump`):
- the self-test of that time (tiles only) passes (3,145,728 pixels, 127–146 ms). Calculator dragged sideways in the band the menu bar
- and the Dock leave free: 152 of 153 frames GPU drag, and along a figure of eight that reaches them, 7 of 153;
- `LORD_GPU_VERIFY=1` compared 160 GPU drag frames with the CPU (W up to 462 × 592), 0 pixels differ in any.
- LordBench's Desktop impact gets 1 GPU drag frame of 2,024 at 1280 × 800: its window, with its shadow, always
- reaches the Dock's or the menu bar's blurred backdrop (1,377 refused for that) and its turning square
- makes the layer be painted whole (646); result with GPU drag on: 72.3 fps alone (p50 12.0 ms, p99 16.7 ms),
- 63.8 fps under load (p50 14.4, p99 27.8 ms, 10.8 % late); `LORD_GPU_DRAG=0`: 73.9 fps, 12.0 / 16.7 ms alone,
- 62.0 fps, 14.8 / 26.3 ms, 15.6 % late under load (the same within llvmpipe's noise). `LORD_GPU=0` (CPU
- composition): the same drags paint as before (no GPU drag tried) and LordBench gives 75.0 fps alone and under load
- (p50 5.1 / 5.7 ms). After the runs the VM's normal session (`lordos.service`) was started again.
- - **Fixed after an adversarial review of step 10** (on VM 116; the runtime runs above came before these fixes
- and were not repeated, the VM's own session was left alone):
- - *Wrong pixels under a rounded clipping box painted after the window.* A view with `overflow: hidden` and
- rounded corners that paints nothing itself still saves and restores its corners around its children, which
- darkens what is below them by about 1 level; `node_paints` did not count it, so GPU drag left it out inside W. It
- now counts (`ui/paint.c`). New `engine-test` run `corner` (such a 200 × 150 box, radius 60, over the
- window's path), compared frame by frame with the GPU path: without the fix 59 of its 91 frames differ; with
- it 0 differ (its box is in every frame's damage: of 90 frames that use the copy, 89 are refused as `after`,
- 1 for the layer).
- - *The pixel position no longer comes from `gl_FragCoord`*, which GLSL ES 1.00 makes `mediump`: with 16-bit
- floats it cannot tell x or y from the next pixel past 1024. GPU drag has its own vertex shader that passes a
- `highp` varying in pixels (`v_px`, the quad's corners on pixel edges) and the shader uses `floor(v_px)`. The
- self-test gained a placement pass: a framebuffer as large as the largest output and at least 4096 × 2048
- (else the largest the GPU allows, and the log says so), a copy of what is below that size and a layer at an
- odd offset (37, 21) reaching its far edges, every pixel a different random value, compared with the CPU. A
- layer or output past what it covered turns GPU drag off (`gpu_gdrag_ready(out)` refuses such an output up front).
- Checked headless on VM 116 (a test driver that includes `gpu.c`, a surfaceless GLES2 context on llvmpipe):
- the full self-test passes (11,373,321 pixels at 1920 × 1080, 17,678,025 for a 5120 × 2880 output); with the
- same shader rounding `v_px` as 16-bit floats would, the tiles pass and the placement pass fails from x = 1024
- on (6,207,545 pixels differ), so the old test alone would have passed it.
- - *A failed GPU drag upload no longer shows a frame with a stale W:* when the quad cannot be drawn `gpu_frame_ex`
- returns -2 before presenting, and `main.c` joins W to the damage and paints it on the CPU in the next frame
- without trying GPU drag (`gdragcpu`), keeping the GPU on. Headless, with a layer larger than the self-test covered:
- -2, nothing presented, GPU drag off; again with GPU drag off: -2. A real failed upload was not provoked, and `main.c`'s
- side has only been built, not run.
- - *`layer.premul_bad` on a layer rendered on the CPU path* (no hole map) was never computed: it is now set,
- so GPU drag never trusts such a layer after the GPU comes back.
- - `LORD_GPU_VERIFY`'s CPU reference walk paints on a scratch canvas of the scene's size (an ancestor's rounded
- corner above or left of W read before its old W-sized buffer).
- - The self-test runs in `gpu_init`, not in the first drag frame, and its outcome is kept per GL renderer and
- version across contexts (a GPU restart does not run it again): 311–406 ms on llvmpipe the first time
- (it was 75–146 ms without the placement pass), about 1 ms after. Stale GL errors are drained before it,
- dithering is off for the quad, the error drain before an upload is bounded, and GPU drag's program and textures
- are freed when it does not turn on.
- - `make -j8` (GPU=1) and lord-server with GPU=0: no warnings; `make test`: 23 passed, 0 failed, 13 skipped;
- `engine-test`: 3,690 checks, 0 failures, `drag_golden_{cpu,gpu}.txt` unchanged (250 of 1,856 frames that
- use the copy still GPU drag); `canvas-test`: 8,621,376 cases, 0 differ.
- - **Where a frame's time goes, measured per frame** (0.8.6, in development; `docs/BENCHMARK.md`, "Frame phases").
- On the Pi 5 with its monitor a loaded frame is built in about 13 ms and still the monitor shows 30 frames a
- second, 98 % of them late: the time outside the "build" number (JS before the frame, the GPU's own work, the wait
- for the vblank) was not measured. lord-server now records, for every frame the main display shows, while
- LordBench records or a scripted move runs (`bench/lbframes.c`, filled only by `main.c` and `gpu.c`; nothing comes
- from a helper, and `lb_msg_valid` is unchanged since no new result id exists):
- - the flip event to lord-server running (`wake`), that wake to `render()` (input, LordBench's scripted step, JS),
- `render()` itself, its layout and paint, the UI texture's upload (time and pixels), GPU drag's texture uploads (time,
- pixels, whether one was whole), `eglSwapBuffers`, the framebuffer and page flip ioctl, the GPU's finish time
- after the flip was queued, the wait to the vblank, and wake to flip;
- - the GPU's finish time is a native fence taken after `eglSwapBuffers` (`EGL_ANDROID_native_fence_sync`) and read
- once at the frame's flip with `SYNC_IOC_FILE_INFO` (the sync file's signal time): one ioctl a frame, no wait, no
- polling, and nothing at all while not recording; without the extension it is "unknown"; a frame scanned out
- straight (a fullscreen app's buffer) has no upload, swap or GPU time of its own, so it records none and drops a
- fence left from before instead of reporting the last composed frame's;
- - each frame against the first vblank after it started: on time (shown within half a period of it), CPU-late
- (the flip was queued after that vblank), GPU-late (queued before it, the GPU finished after it) or other;
- - per frame whether the paint threads were on, whether GPU drag composed it or why not (each refusal and, for `layer`,
- its cause: `invalid`, `rendering`, `holes`, `surfaces`, `premul`, `opacity`, `part` and the rest, `GDRAG_L_*` in
- `ui/ui.h`), GPU drag's whole uploads and their pixels, and frames not shown (`gpu_frame_ex`'s -2).
- LordBench's desktop result has them as `frames.phases.alone` and `frames.phases.load` (p50 and p99 in ms, and
- counts), and the session log gets `lordbench: desktop alone|under load: phases, …`; the `drag (scripted): …` line
- ends with the same text, and its GPU drag part now lists `… catching up` and the layer's causes. Without a monitor the
- frame's end is its presentation, on the pacing grid. The System Information page is unchanged (it does not show
- them). Checked on VM 116: `lordbench-test` (1,192 ok) feeds known frames and checks each class, percentile and
- count, the text and a short buffer; and a desktop run in an isolated headless session of the worktree's
- lord-server (a test theme moving one window with `lord.wm.script`, CPU composition, one viewer on its
- `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.
- - **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
- on the CPU, inside the frame. Now a frame GPU drag would compose but whose textures lack more than 262,144 pixels
- (`GDRAG_FEED_PX`, 1 MB) is painted by the CPU (`GDRAG_R_FEED`, "catching up"; the same pixels), and after its flip is
- queued, while the CPU waits for the vblank, a slice of up to that many pixels goes up (`paint_gdrag_feed`,
- `gpu_gdrag_feed`: rectangles cut by rows; each texture is asked first whether it holds that display's pixels at that
- size, else it is allocated and all of it is sent in slices; GL errors left by earlier calls are cleared first, so
- they cannot turn GPU drag off there). Only frames refused for that reason send slices. A GPU drag frame can still send a
- texture whole when it finds one that is another display's or the wrong size (after the GPU context is made
- again, or the layer's first frame within the budget), as before.
- Each texture now knows whose pixels it holds; the dirty list keeps 16 rectangles and, when full, merges the two
- whose box adds the fewest pixels (the last one used to grow, which could make a few small changes most of the
- screen). Frames don't overlap (the next starts after the flip), so the textures need no second copy. Checked on
- VM 116: `engine-test`'s stub GPU does the same (a texture made again is filled with a pattern no frame has); all
- 2,417 frames of `drag_golden_gpu.txt` match and the five extra runs match the GPU path frame by frame; no GPU drag
- frame sent a texture whole, and the most one GPU drag frame sent fell from 934,022 to 170,330 pixels in the long run
- (1024 × 640); 241 of 1,856 frames that use the copy are GPU drag (250 before: 9 catch up), 2,358,312 pixels went up
- between frames; `pause` 45 of 61 (54), `two` 148 of 240 (150), `app` 2 of 180 (5), `ancedge` 12 of 90 (15),
- `corner` 0 of 90. Not run on a GPU yet.
- - **The paint threads turn on by the whole frame too** (0.8.6, in development): on when the frame (`render_frame`:
- layout, paint, upload, submit) takes more than 60 % of a period, or painting more than 70 % as before; off after
- 60 frames in a row with painting under 25 % and the frame under 45 %. On the Pi 5 under load painting took about
- 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
- 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.
- - Now, while the flip of frame N is pending, frame N+1's CPU part is done ahead: pointer input and LordBench's
- scripted step are dispatched, the JS frame callbacks and the layout run and its damage is painted into the
- display's scene (`out_prepare`), and at N's flip event only its upload, `gpu_frame_ex` (or the copy into the dumb
- buffer) and the page flip are left (`out_submit`, through the same `out_present` a frame built at once uses;
- `render_frame` is split into `out_paint` and `out_present`). GPU drag's textures catch up after the submission and
- before the next frame is painted. At most one frame is prepared; with nothing pending a frame is still built and
- 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
- period, off after 60 in a row under 40 % (`fpipe_note`; `-d` logs each change), because when frames already fit
- a prepared frame shows input one vblank later.
- - The rules: what changes between a frame's paint and its submission goes into the next frame (the prepared one
- is shown as a frame painted at that moment would have been; the cursor and a Linux app's new buffer are still
- taken at submission). A prepare that paints nothing tries nothing more until the flip (no busy loop). A
- prepared frame that can't be submitted as painted (the scene reallocated, the GPU context or output changed, or
- for a GPU drag frame the drag layer began, ended, changed display or reallocated: the new `paint_gdrag_epoch`) is undone
- into the next frame's damage, its GPU drag rectangle included, and that frame is built at once; `cpu_takeover`
- (recording, protected windows for a remote viewer, a failed frame), `gpu_start`, `outputs_apply` (hotplug,
- Settings → Displays) and `display_detach` (a session switch, before the card's master goes) undo it first, and
- so does the screen going off (DPMS), so it is never shown stale when it comes back. Stopping the GPU for a
- recording or protected windows (`cpu_switch`, whose `cpu_takeover` sets the dumb buffer with a modeset) never
- runs in a render that only prepares, while the flip is pending; and nothing is prepared in a render whose
- built frame still has GPU drag's catch-up queued (it would run between that prepared frame's paint and its upload).
- Direct scanout, the remote desktop's read-back, the protected windows' black, `LORD_GPU_VERIFY` and the -2
- path are decided at submission by the same code. The Linux apps' frame callbacks go with a submitted frame,
- never with one only prepared.
- - LordBench records a prepared frame at its submission: its prepare's paint, its submission's upload, swap and
- flip ioctl, both as `renderMs`, and a new `heldMs` (prepared → submitted) with a `prepared` count, in
- `frames.phases` and the `drag (scripted):` line (`… prepared ahead N (held for the flip p50/p99)`); such a
- frame is on time when shown by the first vblank after the wake that submitted it, and the synthetic pointer's
- events end at its own presentation (`lbf_painted`, `lbf_submitted`; `lbf_frame` gets its prepare plus its
- submission).
- - Checked on VM 116: `make -j8` and the changed files with `GPU=0`: no warnings; `make test`: 23 passed, 0 failed,
- 13 skipped; the new `fpipe-test` (39 checks: the switch, the auto mode's hysteresis, every decision, and a
- display on a vblank grid where 13 ms of CPU, 1 ms to submit and 3 ms of GPU give 299 flips in 600 periods
- without the pipeline and 598 with it, a 20 ms frame 299 and 475, and a light frame 599 either way with auto
- never engaging); `engine-test` (6,883 checks, 0 failures) runs every drag case again with each frame presented
- only after the next frame's changes, as a prepared frame is, and all 2,417 frames match
- `drag_golden_gpu.txt`, unchanged, with no change between paint and submission moving the GPU drag epoch;
- `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.
- - `make -j8` and lord-server with `GPU=0` (no EGL, GBM or GLES linked): no warnings; `make test`: 23 passed, 0
- failed, 13 skipped, every suite's checks passing; `engine-test`: 4,146 checks, 0 failures.
- - **`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
- different keys are remembered; the 65th is logged with `(further unknown style keys are not logged)` and later
- ones are not. Nothing else changes: the key is still ignored the same way (`docs/THEMES-GUIDE.md`).
-- **The corners of rounded windows below a dragged window now match a full repaint** (in development for 0.8.6; the
- one pixel change of the drag-frame work, approved by the maintainer on 2026-10-28; `ui/paint.c`). A drag frame
+ painted this frame, that the layer stays opaque there and that no ancestor's rounded corner reads it).
+- **The corners of rounded windows below a dragged window now match a full repaint** (in development for 0.8.6; step
+ 9, the one pixel change of the drag-frame work's steps, approved by the maintainer on 2026-10-28; `ui/paint.c`). A drag frame
copies what is below the window and then walks the tree to the window, painting nothing before it; that walk still
saved and restored the corners of every rounded `overflow: hidden` node on the way, and the restore blended each
saved pixel over the same pixel, which leaves it one level darker where the corner's coverage is partial. Now
@@ -609,6 +447,212 @@ of the matching [GitHub release](https://github.com/lordbasex/LordOS/releases),
same hashes came out of 001633b's code with only this change (and the test's entry points) added. The
differential harnesses against 001633b's `paint.c` (5,324 frame outputs in the largest) are still identical: their
scenes have no rounded `overflow: hidden` node below the window.
+- **The dragged window composited on the GPU, with the CPU's pixels ("GPU drag", in development for 0.8.6; step
+ 10, approved by the maintainer on 2026-10-28; `ui/paint.c`, `gpu/gpu.c`, `main.c`; `docs/GPU.md`, "The dragged
+ window on the GPU").** On the GPU
+ path a frame that uses the copy of what is below the window paints only the strips of its damaged box around
+ the window's rectangle W; the GPU writes W itself, from two textures of its own (the layer and the copy of what
+ is below), with one shader that does `blit_row`'s integer arithmetic (k = 256, `over_alpha`) in 24-bit floats,
+ where every value is an integer below 2^24 and every scaling a power of two, so the pixels are the CPU's bit for
+ bit. The textures get only what changed since the GPU last had them (the layer's part, the copy's partial
+ rebuilds), so the per-frame upload of the old and new window box (2.2–2.6 MB on the Pi) becomes the strips and
+ the layer's part.
+ - **When:** only after `below_ready` decided to use the copy (its decisions are unchanged), on the display that
+ owns the layer, one damaged box, no rotation and no fullscreen app; the layer valid and painted as it is (the
+ same opacity, no full render pending, no app window in it, no pixel with a colour above its alpha:
+ `layer.premul_bad`, checked where `layer_holes` already walks it); W is the blit cut by the ancestors' clips
+ and the box; no ancestor paints over W afterwards (`below_ancestors_ok`); no app window of layer 0 is drawn
+ into W (`wl_draws_meet`); the paint order around the window is known and no node painted after it that paints
+ anything meets the box (`damage_walk` notes them, grown by a backdrop blur's reach and a transform's edge).
+ Anything that changes while the strips are painted (the layer rendered again elsewhere, an app window) paints
+ W on the CPU in the same frame. Otherwise the frame is painted as before.
+ - **The GPU side** is off unless it proves itself: a `highp` fragment shader with at least 24-bit floats
+ (`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
+ 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
+ textures if they are still that display's, else paints W on the CPU; direct scanout, a failed frame or the GPU
+ going away paint it again. A frame whose quad cannot be drawn (a failed upload, GPU drag turned off) is not shown
+ at all (`gpu_frame_ex` returns -2): the display keeps the frame before and the next one paints W on the CPU. `LORD_PAINT_VERIFY` leaves W out on GPU drag frames (`LORD_GPU_VERIFY` checks it). The
+ `drag: …` and `drag (scripted): …` lines end with `GPU drag: N of M frames (Q quads), strips … Mpx, uploaded below …
+ Mpx, layer … Mpx (not: … layer, … clip, … ancestor, … app, … after, … post)`.
+ - Checked on VM 116 (x86_64): `canvas-test` compares GPU drag's shader written in C (`canvas_gdrag_model`) with
+ `blit_row_c` and the SIMD row over all 8,421,376 valid (alpha, colour, destination) combinations, every alpha
+ pair, and 200,000 random pixels: 0 differ (NEON not run: no ARM machine was used). `engine-test` has a third
+ path, `gpu-drag`: the GPU path with GPU drag and a stub GPU that keeps the UI texture, the two textures (only their dirty
+ rectangles) and `main.c`'s bookkeeping, and writes W with `canvas_gdrag_model`; all 2,417 frames equal
+ `drag_golden_gpu.txt`, 250 of the 1,856 frames that use the copy are composited this way (refused: 436 layer,
+ 287 app, 883 after: the big scene's window is mostly near the menu bar or the Dock). Four runs without goldens
+ are compared frame by frame with the GPU path: a 30-frame pause with no damage (54 of 61 GPU drag), two displays side
+ by side (150 of 240), the window over an app window below (5 of 180), and the window against a rounded,
+ bordered container's corner (15 of 90; 44 refused for the ancestor); the single-display ones as the GPU shows
+ them (the app windows under the UI texture, W written over both). Taking out the after-node, app-window or
+ ancestor check fails the test; the layer's own checks (app holes, invalid pixels) are not reached by these
+ scenes. `make test`: 23 passed, 0 failed, 13 skipped; `engine-test`: 3,688 checks, 0 failures. With GPU=0 the
+ build has no warnings.
+ - On VM 116 at runtime (llvmpipe forced with `LORD_GPU=1`, an isolated session lent the card by
+ `tests/seat_cycle.c`, a test scene moved by `lord.wm.script`): the self-test of that time (tiles only, in the
+ first drag frame) passes (75–113 ms); with
+ `LORD_GPU_VERIFY=1`, 1,481 of 1,483 frames were GPU drag and 0 pixels differed in any; across 4 GPU context
+ re-creations during the move, 1,328 GPU drag frames, 0 differ; with `LORD_PAINT_VERIFY=16`, 0 pixels differ from a
+ full repaint outside W in 92 checks. Layout and paint of a drag frame: 0.29–0.35 ms with GPU drag, 0.92 ms without
+ (llvmpipe's own composition dominates the rest, so this says nothing yet about the Pi). `tests/gpu_cycle.sh` 10
+ cycles: 38 fds and 226.6–227.6 MB throughout. A real screenshot of GPU drag frames was taken (seat-cycle's snapshot).
+ The Pi 5 is below.
+ - **With the real desktop GPU drag never composed a frame, fixed:** the list of nodes painted after the window
+ held 128 boxes and refused every frame once it was full, and LordOS's menu bar and Dock alone fill it
+ (`drag: … GPU drag: 0 of 250 frames … 248 after`). The list now grows as needed (up to 65,536 boxes, then the
+ frame is refused as before) and skips a box inside the one noted just before it (an icon inside its bar:
+ it meets the damaged box only if the bar does), so the menu bar and the Dock are 2 boxes. The decision is
+ the same for every frame that fit before. `engine-test`'s `pause` run now has 300 more nodes painted after
+ the window, each in its own box: with the old 128-box list it fails (`GPU drag composed 0 of 61`), with this one
+ 54 of 61 frames, the same as the GPU path frame by frame.
+ - Checked again on VM 116 with the default theme (an isolated 1280 × 800 session lent the card by
+ `seat-cycle`, llvmpipe, driven over the remote desktop socket; real screenshots with QMP `screendump`):
+ the self-test of that time (tiles only) passes (3,145,728 pixels, 127–146 ms). Calculator dragged sideways in the band the menu bar
+ and the Dock leave free: 152 of 153 frames GPU drag, and along a figure of eight that reaches them, 7 of 153;
+ `LORD_GPU_VERIFY=1` compared 160 GPU drag frames with the CPU (W up to 462 × 592), 0 pixels differ in any.
+ LordBench's Desktop impact gets 1 GPU drag frame of 2,024 at 1280 × 800: its window, with its shadow, always
+ reaches the Dock's or the menu bar's blurred backdrop (1,377 refused for that) and its turning square
+ makes the layer be painted whole (646); result with GPU drag on: 72.3 fps alone (p50 12.0 ms, p99 16.7 ms),
+ 63.8 fps under load (p50 14.4, p99 27.8 ms, 10.8 % late); `LORD_GPU_DRAG=0`: 73.9 fps, 12.0 / 16.7 ms alone,
+ 62.0 fps, 14.8 / 26.3 ms, 15.6 % late under load (the same within llvmpipe's noise). `LORD_GPU=0` (CPU
+ composition): the same drags paint as before (no GPU drag tried) and LordBench gives 75.0 fps alone and under load
+ (p50 5.1 / 5.7 ms). After the runs the VM's normal session (`lordos.service`) was started again.
+ - **Fixed after an adversarial review of step 10** (on VM 116; the runtime runs above came before these fixes
+ and were not repeated, the VM's own session was left alone):
+ - *Wrong pixels under a rounded clipping box painted after the window.* A view with `overflow: hidden` and
+ rounded corners that paints nothing itself still saves and restores its corners around its children, which
+ darkens what is below them by about 1 level; `node_paints` did not count it, so GPU drag left it out inside W. It
+ now counts (`ui/paint.c`). New `engine-test` run `corner` (such a 200 × 150 box, radius 60, over the
+ window's path), compared frame by frame with the GPU path: without the fix 59 of its 91 frames differ; with
+ it 0 differ (its box is in every frame's damage: of 90 frames that use the copy, 89 are refused as `after`,
+ 1 for the layer).
+ - *The pixel position no longer comes from `gl_FragCoord`*, which GLSL ES 1.00 makes `mediump`: with 16-bit
+ floats it cannot tell x or y from the next pixel past 1024. GPU drag has its own vertex shader that passes a
+ `highp` varying in pixels (`v_px`, the quad's corners on pixel edges) and the shader uses `floor(v_px)`. The
+ self-test gained a placement pass: a framebuffer as large as the largest output and at least 4096 × 2048
+ (else the largest the GPU allows, and the log says so), a copy of what is below that size and a layer at an
+ odd offset (37, 21) reaching its far edges, every pixel a different random value, compared with the CPU. A
+ layer or output past what it covered turns GPU drag off (`gpu_gdrag_ready(out)` refuses such an output up front).
+ Checked headless on VM 116 (a test driver that includes `gpu.c`, a surfaceless GLES2 context on llvmpipe):
+ the full self-test passes (11,373,321 pixels at 1920 × 1080, 17,678,025 for a 5120 × 2880 output); with the
+ same shader rounding `v_px` as 16-bit floats would, the tiles pass and the placement pass fails from x = 1024
+ on (6,207,545 pixels differ), so the old test alone would have passed it.
+ - *A failed GPU drag upload no longer shows a frame with a stale W:* when the quad cannot be drawn `gpu_frame_ex`
+ returns -2 before presenting, and `main.c` joins W to the damage and paints it on the CPU in the next frame
+ without trying GPU drag (`gdragcpu`), keeping the GPU on. Headless, with a layer larger than the self-test covered:
+ -2, nothing presented, GPU drag off; again with GPU drag off: -2. A real failed upload was not provoked, and `main.c`'s
+ side has only been built, not run.
+ - *`layer.premul_bad` on a layer rendered on the CPU path* (no hole map) was never computed: it is now set,
+ so GPU drag never trusts such a layer after the GPU comes back.
+ - `LORD_GPU_VERIFY`'s CPU reference walk paints on a scratch canvas of the scene's size (an ancestor's rounded
+ corner above or left of W read before its old W-sized buffer).
+ - The self-test runs in `gpu_init`, not in the first drag frame, and its outcome is kept per GL renderer and
+ version across contexts (a GPU restart does not run it again): 311–406 ms on llvmpipe the first time
+ (it was 75–146 ms without the placement pass), about 1 ms after. Stale GL errors are drained before it,
+ dithering is off for the quad, the error drain before an upload is bounded, and GPU drag's program and textures
+ are freed when it does not turn on.
+ - `make -j8` (GPU=1) and lord-server with GPU=0: no warnings; `make test`: 23 passed, 0 failed, 13 skipped;
+ `engine-test`: 3,690 checks, 0 failures, `drag_golden_{cpu,gpu}.txt` unchanged (250 of 1,856 frames that
+ use the copy still GPU drag); `canvas-test`: 8,621,376 cases, 0 differ.
+ - **On the Raspberry Pi 5 with its monitor** (V3D, 1920×1080 at 60 Hz, LordBench → Desktop impact, 2026-10-28,
+ 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 -->
+- **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
+ on the CPU, inside the frame. Now a frame GPU drag would compose but whose textures lack more than 262,144 pixels
+ (`GDRAG_FEED_PX`, 1 MB) is painted by the CPU (`GDRAG_R_FEED`, "catching up"; the same pixels), and after its flip is
+ queued, while the CPU waits for the vblank, a slice of up to that many pixels goes up (`paint_gdrag_feed`,
+ `gpu_gdrag_feed`: rectangles cut by rows; each texture is asked first whether it holds that display's pixels at that
+ size, else it is allocated and all of it is sent in slices; GL errors left by earlier calls are cleared first, so
+ they cannot turn GPU drag off there). Only frames refused for that reason send slices. A GPU drag frame can still send a
+ texture whole when it finds one that is another display's or the wrong size (after the GPU context is made
+ again, or the layer's first frame within the budget), as before.
+ Each texture now knows whose pixels it holds; the dirty list keeps 16 rectangles and, when full, merges the two
+ whose box adds the fewest pixels (the last one used to grow, which could make a few small changes most of the
+ screen). Frames don't overlap (the next starts after the flip), so the textures need no second copy. Checked on
+ VM 116: `engine-test`'s stub GPU does the same (a texture made again is filled with a pattern no frame has); all
+ 2,417 frames of `drag_golden_gpu.txt` match and the five extra runs match the GPU path frame by frame; no GPU drag
+ frame sent a texture whole, and the most one GPU drag frame sent fell from 934,022 to 170,330 pixels in the long run
+ (1024 × 640); 241 of 1,856 frames that use the copy are GPU drag (250 before: 9 catch up), 2,358,312 pixels went up
+ between frames; `pause` 45 of 61 (54), `two` 148 of 240 (150), `app` 2 of 180 (5), `ancedge` 12 of 90 (15),
+ `corner` 0 of 90. Not run on a GPU yet.
+- **The paint threads turn on by the whole frame too** (0.8.6, in development): on when the frame (`render_frame`:
+ layout, paint, upload, submit) takes more than 60 % of a period, or painting more than 70 % as before; off after
+ 60 frames in a row with painting under 25 % and the frame under 45 %. On the Pi 5 under load painting took about
+ 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
+ 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.
+ - Now, while the flip of frame N is pending, frame N+1's CPU part is done ahead: pointer input and LordBench's
+ scripted step are dispatched, the JS frame callbacks and the layout run and its damage is painted into the
+ display's scene (`out_prepare`), and at N's flip event only its upload, `gpu_frame_ex` (or the copy into the dumb
+ buffer) and the page flip are left (`out_submit`, through the same `out_present` a frame built at once uses;
+ `render_frame` is split into `out_paint` and `out_present`). GPU drag's textures catch up after the submission and
+ before the next frame is painted. At most one frame is prepared; with nothing pending a frame is still built and
+ 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
+ period, off after 60 in a row under 40 % (`fpipe_note`; `-d` logs each change), because when frames already fit
+ a prepared frame shows input one vblank later.
+ - The rules: what changes between a frame's paint and its submission goes into the next frame (the prepared one
+ is shown as a frame painted at that moment would have been; the cursor and a Linux app's new buffer are still
+ taken at submission). A prepare that paints nothing tries nothing more until the flip (no busy loop). A
+ prepared frame that can't be submitted as painted (the scene reallocated, the GPU context or output changed, or
+ for a GPU drag frame the drag layer began, ended, changed display or reallocated: the new `paint_gdrag_epoch`) is undone
+ into the next frame's damage, its GPU drag rectangle included, and that frame is built at once; `cpu_takeover`
+ (recording, protected windows for a remote viewer, a failed frame), `gpu_start`, `outputs_apply` (hotplug,
+ Settings → Displays) and `display_detach` (a session switch, before the card's master goes) undo it first, and
+ so does the screen going off (DPMS), so it is never shown stale when it comes back. Stopping the GPU for a
+ recording or protected windows (`cpu_switch`, whose `cpu_takeover` sets the dumb buffer with a modeset) never
+ runs in a render that only prepares, while the flip is pending; and nothing is prepared in a render whose
+ built frame still has GPU drag's catch-up queued (it would run between that prepared frame's paint and its upload).
+ Direct scanout, the remote desktop's read-back, the protected windows' black, `LORD_GPU_VERIFY` and the -2
+ path are decided at submission by the same code. The Linux apps' frame callbacks go with a submitted frame,
+ never with one only prepared.
+ - LordBench records a prepared frame at its submission: its prepare's paint, its submission's upload, swap and
+ flip ioctl, both as `renderMs`, and a new `heldMs` (prepared → submitted) with a `prepared` count, in
+ `frames.phases` and the `drag (scripted):` line (`… prepared ahead N (held for the flip p50/p99)`); such a
+ frame is on time when shown by the first vblank after the wake that submitted it, and the synthetic pointer's
+ events end at its own presentation (`lbf_painted`, `lbf_submitted`; `lbf_frame` gets its prepare plus its
+ submission).
+ - Checked on VM 116: `make -j8` and the changed files with `GPU=0`: no warnings; `make test`: 23 passed, 0 failed,
+ 13 skipped; the new `fpipe-test` (39 checks: the switch, the auto mode's hysteresis, every decision, and a
+ display on a vblank grid where 13 ms of CPU, 1 ms to submit and 3 ms of GPU give 299 flips in 600 periods
+ without the pipeline and 598 with it, a 20 ms frame 299 and 475, and a light frame 599 either way with auto
+ never engaging); `engine-test` (6,883 checks, 0 failures) runs every drag case again with each frame presented
+ only after the next frame's changes, as a prepared frame is, and all 2,417 frames match
+ `drag_golden_gpu.txt`, unchanged, with no change between paint and submission moving the GPU drag epoch;
+ `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) -->
+- **`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
+ different keys are remembered; the 65th is logged with `(further unknown style keys are not logged)` and later
+ ones are not. Nothing else changes: the key is still ignored the same way (`docs/THEMES-GUIDE.md`).
### Fixed
@@ -642,6 +686,57 @@ of the matching [GitHub release](https://github.com/lordbasex/LordOS/releases),
older Pi 4 and Pi 5 kernel with `get_throttled` set, clear and "now"; both sources; a malformed value and a second
line; a Pi with neither; a machine that isn't a Pi with both files; 790 checks) and
`tests/sysinfo_model_test.mjs` (`piStatus`, 68 checks). `build/lordbench-test` still passes (1,198 checks).
+- **No black squares at the corners of a dragged window** (0.8.6, in development). While any window was dragged, the
+ area just outside its rounded corners showed opaque black squares, on the CPU and the GPU path (seen on VM 116 with
+ Calculator; still windows were fine). The drag layer paints the window on a transparent canvas, and a rounded
+ `overflow: hidden` window saves its corner squares before its children paint and restores them afterwards
+ (`canvas_corners_restore`/`canvas_corners_restore4` in `server/src/canvas.c`). The restore mixed the saved pixel in
+ with `blend()`, which takes its source as opaque: the alpha came out as `over(a, dst)`, so the window's shadow
+ saved over transparency (or the GPU path's sentinel) came back opaque, its premultiplied colour near black, and
+ the layer was blitted over the desktop with those squares. The restore now mixes both premultiplied pixels in
+ every channel, alpha included (`mix_px`); where both are opaque, as on the screen's canvas, it gives `blend()`'s
+ pixel exactly, so still windows and everything else on an opaque canvas are unchanged. On the GPU path this also
+ gives transparent corners where a rounded window sits over a Linux app's hole (alpha 0), which were black before.
+ New `engine-test` check `test_drag_corners`: a rounded window with a shadow, a title bar and a status bar over a
+ light box, dragged three frames (one renders the layer, two copy it), on both paths, with one radius and with
+ per-corner radii; each corner square must equal a full repaint within 2 levels (before: 217 to 221 levels, all 12
+ corner pixels dark). The golden hashes of `test_drag_exact` were written again after a pixel-by-pixel comparison
+ of every frame with the code before: on the CPU path 498,743 pixels in the dragged window's corner squares and
+ 445,199 inside the Dock's or the menu bar's backdrop blur, with such a square within the blur's reach, differed in
+ 2,386 of 2,417 frames (GPU path: 498,692 and 431,316 in 2,387), none anywhere else. The pixels that differ from a
+ full repaint in the long run go down from 2,217 to 248 (CPU path) and from 70,882 to 70,864 (GPU path).
+
+- **A rotated or scaled node now repaints when its own style changes** (approved by the maintainer on 2026-10-28).
+ A node with its own `rotate`/`scaleX`/`scaleY` is painted into a cached raster (`tfl[]` in `server/src/ui/paint.c`).
+ `damage_walk` cleared the node's `paint_dirty` before its children, and `tf_check`, which runs after them, tested
+ that flag, so a change to the node's own background, border, radius or gradient (`lord.setStyle` or a React
+ render) kept the raster and the old look stayed on screen until something else re-rasterized it. `tf_check` now
+ compares the node's own style with the raster's every time (the same change as the partial-repaint fix below,
+ which found it independently with changes made while a subtree was hidden or unscaled; on this branch it first
+ kept the node's own flag for `tf_check`, which the stricter check replaces). A change of the transform alone still reuses the raster
+ (the compared style leaves the transform out). New `engine-test` check `test_transform_self_restyle` (a 40 × 40 box
+ rotated 15°, its background changed from red to blue, the centre pixel must be blue): it fails without the fix
+ (`ff0000`) and passes with it. The drag goldens (`server/tests/drag_golden_{cpu,gpu}.txt`) are unchanged: 2417
+ frames per path, the same per-frame hashes, 0 pixels differ in the 591 frames switched to the copy of what is
+ below; `make test` on VM 116: 23 passed, 0 failed, 13 skipped; `engine-test`: 3662 checks, 0 failures.
+- **GPU composition without `GL_EXT_unpack_subimage`** (approved by the maintainer on 2026-10-28;
+ `server/src/gpu/gpu.c`). The UI's damage was always uploaded with `GL_UNPACK_ROW_LENGTH_EXT`; a GLES2 driver
+ without that extension ignores it (`GL_INVALID_ENUM`) and reads each damaged rectangle narrower than the screen
+ with the wrong row length, so the uploaded pixels came out sheared. The log line also said "the whole canvas is
+ uploaded", which was not true. Now the extension is read from the GL extension list; without it the damage is
+ uploaded as whole rows in one call when the scene's rows are contiguous (they are: the scene is created with
+ `stride == width`), or one row at a time otherwise, and the log says so. With the extension (every Mesa driver,
+ so every machine LordOS has been tested on) nothing changes. Built with `GPU=1` and `GPU=0` on VM 116 with no
+ warnings; the fallback itself has not run on a driver that lacks the extension.
+
+- **LordBench's turning square and the Cooling page's fans now turn** (approved by the maintainer on 2026-10-28).
+ `apps/sysinfo/scene.jsx` and `sdk/cooling.jsx` called `lord.setStyle(n, 'transform', 'rotate(…deg)')`, and
+ `transform` is not a key the engine takes (it only logged `js: unsupported style 'transform'`), so the desktop
+ test's square never turned and the fans only jumped when React rendered them. They now send the engine's own
+ `rotate` key in degrees (the fans keep `toFixed(1)`, the same angle React sends). The desktop test's window is no
+ longer static: its layer is repainted (in part, where exact) every frame, so desktop-test numbers from before this
+ change measured a lighter scene and aren't comparable (on the Pi 5 with its monitor the turning square took the
+ test from about 59 to 53–58 fps alone before the frame-cost work, Changed).
- **Partial repaints that left stale areas on screen** (the search for the 0.8.2 "grey rectangle", which keeps
several damaged rectangles off by default; `docs/MONITOR.md`, "0.8.6: the search for the grey rectangle"). Two new
`build/engine-test` suites compare every painted frame with a full repaint that bypasses the raster cache of
@@ -707,55 +802,6 @@ of the matching [GitHub release](https://github.com/lordbasex/LordOS/releases),
to 11 rectangles and this one gives one is not investigated.
LordBench's desktop mode in the headless harness (three runs each): 58.9-60.0 fps, build p50 1.25-1.26 ms and p99
5.9-7.6 ms before; 60.0 fps, p50 1.24-1.27 ms and p99 5.95-6.32 ms after.
-- **No black squares at the corners of a dragged window** (0.8.6, in development). While any window was dragged, the
- area just outside its rounded corners showed opaque black squares, on the CPU and the GPU path (seen on VM 116 with
- Calculator; still windows were fine). The drag layer paints the window on a transparent canvas, and a rounded
- `overflow: hidden` window saves its corner squares before its children paint and restores them afterwards
- (`canvas_corners_restore`/`canvas_corners_restore4` in `server/src/canvas.c`). The restore mixed the saved pixel in
- with `blend()`, which takes its source as opaque: the alpha came out as `over(a, dst)`, so the window's shadow
- saved over transparency (or the GPU path's sentinel) came back opaque, its premultiplied colour near black, and
- the layer was blitted over the desktop with those squares. The restore now mixes both premultiplied pixels in
- every channel, alpha included (`mix_px`); where both are opaque, as on the screen's canvas, it gives `blend()`'s
- pixel exactly, so still windows and everything else on an opaque canvas are unchanged. On the GPU path this also
- gives transparent corners where a rounded window sits over a Linux app's hole (alpha 0), which were black before.
- New `engine-test` check `test_drag_corners`: a rounded window with a shadow, a title bar and a status bar over a
- light box, dragged three frames (one renders the layer, two copy it), on both paths, with one radius and with
- per-corner radii; each corner square must equal a full repaint within 2 levels (before: 217 to 221 levels, all 12
- corner pixels dark). The golden hashes of `test_drag_exact` were written again after a pixel-by-pixel comparison
- of every frame with the code before: on the CPU path 498,743 pixels in the dragged window's corner squares and
- 445,199 inside the Dock's or the menu bar's backdrop blur, with such a square within the blur's reach, differed in
- 2,386 of 2,417 frames (GPU path: 498,692 and 431,316 in 2,387), none anywhere else. The pixels that differ from a
- full repaint in the long run go down from 2,217 to 248 (CPU path) and from 70,882 to 70,864 (GPU path).
-
-- **A rotated or scaled node now repaints when its own style changes** (approved by the maintainer on 2026-10-28).
- A node with its own `rotate`/`scaleX`/`scaleY` is painted into a cached raster (`tfl[]` in `server/src/ui/paint.c`).
- `damage_walk` cleared the node's `paint_dirty` before its children, and `tf_check`, which runs after them, tested
- that flag, so a change to the node's own background, border, radius or gradient (`lord.setStyle` or a React
- render) kept the raster and the old look stayed on screen until something else re-rasterized it. `damage_walk`
- now keeps the node's own flag and passes it to `tf_check`. A change of the transform alone still reuses the raster
- (the compared style leaves the transform out). New `engine-test` check `test_transform_self_restyle` (a 40 × 40 box
- rotated 15°, its background changed from red to blue, the centre pixel must be blue): it fails without the fix
- (`ff0000`) and passes with it. The drag goldens (`server/tests/drag_golden_{cpu,gpu}.txt`) are unchanged: 2417
- frames per path, the same per-frame hashes, 0 pixels differ in the 591 frames switched to the copy of what is
- below; `make test` on VM 116: 23 passed, 0 failed, 13 skipped; `engine-test`: 3662 checks, 0 failures.
-- **GPU composition without `GL_EXT_unpack_subimage`** (approved by the maintainer on 2026-10-28;
- `server/src/gpu/gpu.c`). The UI's damage was always uploaded with `GL_UNPACK_ROW_LENGTH_EXT`; a GLES2 driver
- without that extension ignores it (`GL_INVALID_ENUM`) and reads each damaged rectangle narrower than the screen
- with the wrong row length, so the uploaded pixels came out sheared. The log line also said "the whole canvas is
- uploaded", which was not true. Now the extension is read from the GL extension list; without it the damage is
- uploaded as whole rows in one call when the scene's rows are contiguous (they are: the scene is created with
- `stride == width`), or one row at a time otherwise, and the log says so. With the extension (every Mesa driver,
- so every machine LordOS has been tested on) nothing changes. Built with `GPU=1` and `GPU=0` on VM 116 with no
- warnings; the fallback itself has not run on a driver that lacks the extension.
-
-- **LordBench's turning square and the Cooling page's fans now turn** (approved by the maintainer on 2026-10-28).
- `apps/sysinfo/scene.jsx` and `sdk/cooling.jsx` called `lord.setStyle(n, 'transform', 'rotate(…deg)')`, and
- `transform` is not a key the engine takes (it only logged `js: unsupported style 'transform'`), so the desktop
- test's square never turned and the fans only jumped when React rendered them. They now send the engine's own
- `rotate` key in degrees (the fans keep `toFixed(1)`, the same angle React sends). The desktop test's window is no
- longer static: its layer is repainted (in part, where exact) every frame, so desktop-test numbers from before this
- change measured a lighter scene and aren't comparable.
-
- **The desktop under load** (found by LordBench's desktop test; `docs/BENCHMARK.md`, "The desktop under load"): the
compositor's cgroup (`server`) had the same `cpu.weight` as every app scope, and nice values don't count between
cgroups, so an app keeping every core busy took half of the compositor's CPU even at nice 19. On a Raspberry Pi 5
@@ -785,7 +831,9 @@ of the matching [GitHub release](https://github.com/lordbasex/LordOS/releases),
(as without load); the load got the same CPU time. On the Pi 5 with its monitor (GPU composition), two runs: under
load 24.0 → 28.9–30.5 fps, frame build p50 20.1 → 15.4–16.2 ms, the main thread's wait for a CPU down to about
0.07 ms per second; still 94–98 % late, because under the load a frame takes 15–16 ms of the main thread's own CPU
- time to build (7 ms alone) and misses the 16.7 ms refresh. That cause is not found yet.
+ time to build (7 ms alone) and misses the 16.7 ms refresh. That cause is not found yet; the frame-cost work
+ (Changed, "The desktop under load, third step") cuts that build to 12.9 ms with the scene's square turning, and the
+ frame pipeline is built for the rest.
- **LordBench on the Raspberry Pi 5 measured no GPU:** inside `lord-bench`'s sandbox Mesa's loader could not identify
the V3D render node ("failed to retrieve device information") and every GPU measurement was skipped. The sandbox
now also allows reading `/sys/firmware/devicetree` and `/dev/dri` (read-only; the GPU is still reached only
diff --git a/THIRD_PARTY.md b/THIRD_PARTY.md
index 059b7cb..f431ebf 100644
--- a/THIRD_PARTY.md
+++ b/THIRD_PARTY.md
@@ -26,10 +26,12 @@ the components below, each under its own license.
### Local changes to bundled components
-- **QuickJS** (`third_party/quickjs`, version in `VERSION`): adds `size_t JS_GetMallocSize(JSRuntime *rt)`
- (`quickjs.c`, next to `JS_ComputeMemoryUsage`, and its prototype in `quickjs.h`). It returns the
- same `malloc_size` that `JS_ComputeMemoryUsage` reports, without walking every object, so
- `lord.stats()` (`server/src/ui/js.c`) costs O(1). Re-apply it when QuickJS is updated.
+Each change is marked `LordOS patch` in the source and has to be applied again when the component is
+updated. Nothing else in `third_party/` differs from upstream.
+
+| Component (upstream version) | Change | Files | Why | Since |
+|---|---|---|---|---|
+| QuickJS 2025-04-26 (`third_party/quickjs/VERSION`) | Adds `size_t JS_GetMallocSize(JSRuntime *rt)`, which returns `rt->malloc_state.malloc_size`: the same `malloc_size` that `JS_ComputeMemoryUsage` reports, without walking every object, string and shape of the runtime. No existing function or structure changes. | `quickjs.c` (7 lines, just before `JS_ComputeMemoryUsage`), `quickjs.h` (its prototype, after `JS_ComputeMemoryUsage`'s) | `lord.stats()` (`f_stats` in `server/src/ui/js.c`) gives `jsKB` from it in O(1); About, Settings → General and System Information poll it while open, and the full walk grew with the number of objects. Checked equal to `JS_ComputeMemoryUsage`'s `malloc_size` on a runtime with 100,000 objects, a 50,000-entry Map and after GC | 0.8.6 (in development) |
## npm packages (bundled into the theme JavaScript at build time)
diff --git a/docs/BENCHMARK.md b/docs/BENCHMARK.md
index f7e94b7..95735bf 100644
--- a/docs/BENCHMARK.md
+++ b/docs/BENCHMARK.md
@@ -1,6 +1,6 @@
# System Information, LordBench and hardware reports (proposal)
-**Status: design proposal. Built and released in 0.8.5-beta (2026-10-27; see "Work plan for 0.8.5" below): the collector, `lordos-sysreport report|fetch`, the System Information app (Overview, Hardware, Compatibility, Checks, Report), the Sandbox Probe and the shared measurement library `server/src/bench`. LordBench (0.8.6) is in development: the `lord-bench` helper, its CPU, memory, GPU, storage and sustained workloads, the interface (layout, paint, shaping) and video workloads, the desktop-impact mode (the compositor's frames and pointer-to-screen latency under load), the boot test, the guards, `lordos-sysreport bench` and System Information's Performance tab are built, with two of the three reference machines (VM 116 and the Raspberry Pi 5 16 GB; see "Built so far" under 0.8.6); the modest x86 PC reference is not. Community reports (0.8.7) and a `checks` subcommand of `lordos-sysreport` are not built.** It plans three releases and a later stage:
+**Status: design proposal. Built and released in 0.8.5-beta (2026-10-27; see "Work plan for 0.8.5" below): the collector, `lordos-sysreport report|fetch`, the System Information app (Overview, Hardware, Compatibility, Checks, Report), the Sandbox Probe and the shared measurement library `server/src/bench`. LordBench (0.8.6) is in development: the `lord-bench` helper, its CPU, memory, GPU, storage and sustained workloads, the interface (layout, paint, shaping) and video workloads, the desktop-impact mode (the compositor's frames, their phases and pointer-to-screen latency under load), the boot test, the guards, `lordos-sysreport bench` and System Information's Performance tab are built, with two of the three reference machines (VM 116 and the Raspberry Pi 5 16 GB; see "Built so far" under 0.8.6); the modest x86 PC reference is not. Community reports (0.8.7) and a `checks` subcommand of `lordos-sysreport` are not built.** It plans three releases and a later stage:
| Release | What |
|---|---|
@@ -289,9 +289,10 @@ development package.
machine has it (no VA-API on VM 116; the Pi 5's HEVC decoder needs FFmpeg's `v4l2request`, which Debian's FFmpeg
lacks).
- **Desktop impact** (its own button, its own result file `lordbench-desktop.json`): after the quiet wait,
- System Information opens a second window with a scene (cards, shadows and one element meant to turn through
- `lord.setStyle`; in this build it stays still, because the engine has no `transform` style key: fixed in
- development with a `rotate` key, not merged) and lord-server moves that window along a figure of eight through the drag's own path
+ System Information opens a second window with a scene (cards, shadows and a square turned through
+ `lord.setStyle` with the engine's `rotate` key; until 0.8.6's frame-cost work it sent a `transform` key the engine
+ doesn't have and stood still, so desktop results from before that change measured a lighter scene and aren't
+ comparable) and lord-server moves that window along a figure of eight through the drag's own path
(`lord.wm.script`, `grab_script_begin` in `ui/grab.c`: painted once into a layer, one step per frame, no JS per
frame). lord-server records every frame it builds and every frame the main display shows (`bench/lbframes.c`,
from `render()` and the page flips; one atomic read per frame when off): 10 s alone, then 10 s while `lord-bench`
@@ -473,7 +474,8 @@ On the Pi the desktop stays at the refresh rate alone, but under an all-core loa
still got 5.0 GFLOP/s done) it fell to 24 frames per second: a stability problem LordBench found, investigated
below ("The desktop under load"). The first scene moved its window from JS
(`wm.move` every frame) and measured React instead of the compositor (12.8 fps on VM 116); it was replaced by the
-drag's own path in C before these numbers.
+drag's own path in C before these numbers. These rows were measured with the scene's square standing still (it
+sent a style key the engine lacked); with it turning, see "The drag frame's cost" below.
#### The desktop under load (2026-10-28)
@@ -560,10 +562,45 @@ second for a CPU (299 ms per second before the weight). What remains is the fram
monitor shows every other one (about 30 fps). The cause is not found yet; the load keeps four cores busy with
matrix products, and the CPU and the GPU share the Pi's memory, but that has not been measured.
-**What remains.** Under load a frame takes about twice as long to build on the Pi (15–16 ms instead of 7 ms), for
-a cause not measured yet, which no priority fixes; the Pi kernel at `CONFIG_HZ=1000` (`tools/rpi/build-kernel.sh`, a rebuild) is not built.
-
-**The frame pipeline (in development, not yet measured on the Pi).** A frame that takes 15–16 ms to build cannot
+**What remains.** Under load a frame took about twice as long to build on the Pi (15–16 ms instead of 7 ms), which
+no priority fixes. The frame-cost work below cuts what a drag frame paints (build p50 under load about 20 → 12.9 ms
+with the turning square), but the build, the GPU's part and the flip still run one after another and miss the
+16.7 ms refresh under the load, so the rate stays at 30 fps; the frame pipeline below is built for that and not yet
+measured. The Pi kernel at `CONFIG_HZ=1000` (`tools/rpi/build-kernel.sh`, a rebuild) is not built.
+
+#### The drag frame's cost (0.8.6, in development)
+
+The scene's square turns since this work (the `rotate` key above), so the layer of the moved window changes every
+frame and the test is heavier than the one measured before; the "before" rows below are the code before this work
+with the square turning. What changed in a drag frame, all with the same pixels except an approved 1-level change
+at rounded corners below the window (`docs/WINDOWS.md`, "The moving window is a layer" and "Checking it"): only the
+changed part of the window's layer is painted again; what is below the window is painted again only where it
+changed and is copied where the old rule painted everything; nodes the frame skips are no longer walked for their
+rounded corners; the GPU path's hole walk is skipped for a window without app windows; a turn or scale no longer
+lays its node out again; the JS timers no longer look at every pending timer; React sends fewer unchanged props;
+`lord.stats()` reads QuickJS's memory in O(1). On the GPU path the dragged window can also be composed by the GPU
+with the CPU's exact arithmetic ("GPU drag", `docs/GPU.md`, "The dragged window on the GPU").
+
+**Measured on the Pi 5 with its monitor** (1920×1080 at 60 Hz, GPU composition, the installed session with the
+weight and the real-time priority, LordBench → Desktop impact; 2026-10-28):
+
+| Pi 5, monitor | Runs | Alone: frames shown | Build p99 | Late | Under load: frames shown | Build p50 | Late |
+|---|---|---|---|---|---|---|---|
+| Before (square turning) | 3 | 53.2–58.1 fps | 15.7–16.5 ms | 3.1–12.8 % | 23.6–25.1 fps | 19.8–20.3 ms | 100 % |
+| Frame-cost work, `LORD_GPU_DRAG=0` | 2 | 59.8–60.0 fps | 11.3–11.6 ms | 0–0.3 % | 30.1–30.3 fps | 12.9 ms | 98.1–99.2 % |
+| Frame-cost work, GPU drag on | 3 | 52.2–52.9 fps | 21.3–21.7 ms | 13.5–15.0 % | 25.8–27.5 fps | 13.4–14.2 ms | 91.5–99.4 % |
+
+With GPU drag off the desktop is back at the refresh rate alone, and under the load the build fell from about
+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.
+
+**The frame pipeline (in development, not yet measured on the Pi).** 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
@@ -573,19 +610,22 @@ without a monitor, with a driver paced in software or with several displays noth
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. 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. <!-- 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`).
#### Frame phases (0.8.6, in development)
-A frame is started only after the last flip completed (one frame in flight), so any frame whose whole chain (the
-work before `render()`, the build, the GPU's own part, the flip) takes more than one period is shown a vblank late,
-and the rate locks at half the refresh. The build time alone (`desk.p50`/`p99`) can't tell which part was too long.
-So lord-server also records, for every frame the main display shows, while LordBench records or while a scripted
-move runs (`bench/lbframes.c`: `lbf_phase_built` when the frame is submitted, at the end of `render()` or, for a
-frame the pipeline prepared, right after its submission; `lbf_phase_shown` at that frame's flip; all of it measured
-by lord-server itself, never by a helper):
+Without the frame pipeline a frame is started only after the last flip completed (one frame in flight), so any
+frame whose whole chain (the work before `render()`, the build, the GPU's own part, the flip) takes more than one
+period is shown a vblank late, and the rate locks at half the refresh. The build time alone (`desk.p50`/`p99`) can't
+tell which part was too long. So lord-server also records, for every frame the main display shows, while LordBench
+records or while a scripted move runs (`bench/lbframes.c`: `lbf_phase_built` when the frame is submitted, at the
+end of `render()` or, for a frame the pipeline prepared, right after its submission; `lbf_phase_shown` at that
+frame's flip; all of it measured by lord-server itself, never by a helper):
| Phase (JSON key, `[p50, p99]` ms) | From → to |
|---|---|
@@ -630,22 +670,29 @@ monitor a frame is "shown" when it ends (on the pacing grid), so `gpuMs` and the
not show these yet; results keep comparing as before (no new result ids, LordBench 1).
**Checked** on VM 116: `lordbench-test` feeds known frames (one on time, one queued after its vblank, one whose GPU
-finished after it, one not shown) and checks each class, percentile, count and the text. A desktop run of the
-worktree's lord-server in an isolated headless session (a test theme moving one window with `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.
+finished after it, one not shown, a prepared one) and checks each class, percentile, count and the text. A desktop
+run of the branch's lord-server in an isolated headless session (a test theme moving one window with
+`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 GPU drag (default) and twice with `LORD_GPU_DRAG=0` in the session's environment.
-2. From `~/.cache/lordos/session.log`: the `lordbench: desktop … phases` lines and the `drag (scripted):` line, and
- from `~/.local/state/lordos/lordbench-desktop.json` `frames.phases`.
+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.
+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`.
3. Read under load: if most frames are `cpuLate`, the build is too long (`paintMs`, `uploadMs`, `beforeRenderMs`
say which part, and `paintThreads` whether the pool helped); if `gpuLate`, the GPU's own work (`gpuMs`) is; if
`onTime` is high and the rate still 30, the classification is wrong and the flip times must be looked at.
- With GPU drag, `gpuDrag.refused`/`gpuDrag.layer` say what keeps it off and `catchUpMpx` what the slices cost.
+ 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`).
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
diff --git a/docs/FANS.md b/docs/FANS.md
index df5575c..d427b84 100644
--- a/docs/FANS.md
+++ b/docs/FANS.md
@@ -171,11 +171,11 @@ config and socket); the unit never passes them.
renders): the Argon ONE V5 case (aluminium body, fins, the blower, front ports), a Raspberry Pi 5
with a heatsink and fan, a PC tower with a CPU cooler and case fans, or a passive heatsink when no
fan can be driven. Light and dark variants (`docs/polish/fans-*.png`).
-- The fan is meant to turn at a speed proportional to the real duty (eased; still at 0 %; in this build it
- stays still, because the rotors are set through a `transform` style key the engine doesn't have; fixed in
- development with the `rotate` key, not released), and the fins warm
+- The fan turns at a speed proportional to the real duty (eased; still at 0 %), and the fins warm
from blue (40 °C) through amber (65 °C) to orange-red (80 °C). The rotors are turned with
- `lord.setStyle` on their nodes at 20 frames per second, with no React render per frame; the timer
+ `lord.setStyle(id, 'rotate', degrees)` on their nodes at 20 frames per second, with no React render per
+ frame (until 0.8.6, in development, they were sent as a `transform` key the engine doesn't have, so they
+ stood still between React renders and the session log got `js: unsupported style 'transform'`); the timer
stops at 0 %, while the window is minimized and with **Appearance → Reduce motion** (a new
setting, `reduceMotion`). Frames: `docs/polish/fans-anim-1.png` … `-5.png`.
- The curve chart (`FanCurveChart`) shows the steps, the hysteresis band of each step (orange,
diff --git a/docs/GPU.md b/docs/GPU.md
index a846328..14b2461 100644
--- a/docs/GPU.md
+++ b/docs/GPU.md
@@ -174,9 +174,10 @@ on the CPU inside the call, so the first GPU drag frame after such a change miss
- Each texture knows whose pixels it holds (`gdragtout[2]`); a GPU drag frame that would find another display's or the
wrong size still sends all of it (correct, and rare now). The dirty list keeps `GDRAG_DIRTY` (16) rectangles and,
when full, merges the two whose box adds the fewest pixels (it used to grow the last one).
-- Frames don't overlap (a frame starts after the last flip), so the job that read the textures has finished when
- they are written: no second copy of them is needed. If frames are ever built while a flip is pending, each
- texture needs a pair, each with its own dirty list. GLES3 pixel buffers (the GPU doing the tiling) are not used.
+- The textures are only written at a frame's submission and in the catch-up right after it, never between a frame's
+ paint and its upload: with the frame pipeline (below) the next frame is painted ahead into the CPU's scene only, and
+ its uploads wait for its submission. GL orders those writes after the draws that read the textures, so no second
+ copy of them is kept. GLES3 pixel buffers (the GPU doing the tiling) are not used.
`engine-test`'s stub GPU does the same as `main.c` and `gpu.c` (a texture made again is filled with a pattern no
frame has, so a pixel the slices missed shows): every frame matches, and it checks that no GPU drag frame has more than
@@ -250,10 +251,19 @@ and the `layer` refusals by cause (`GDRAG_L_*` in `ui/ui.h`: `gone`, `invalid`,
makes the layer be painted whole. Its numbers with GPU drag on and with `LORD_GPU_DRAG=0` are the same within
llvmpipe's noise.
-**Not checked yet:** the Raspberry Pi 5 (V3D), the machine this is for: its self-test, `LORD_GPU_VERIFY=1`
-over full LordBench desktop runs alone and under load, a perf run, a real screenshot and one run with
-`LORD_SW_CURSOR=1`. Until then no gain is claimed. Near the menu bar or the Dock the frame is still
-painted by the CPU.
+**On the Raspberry Pi 5** (V3D, its 1920×1080 monitor; LordBench's Desktop impact, 2026-10-28, with the build
+before the uploads in slices and the phase timing): 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 (`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 frame pipeline (0.8.6, in development)
@@ -335,7 +345,9 @@ before the flips themselves came every other vblank) and the rate can double.
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.
+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) -->
## The CPU path on several threads (0.8.5)
@@ -501,6 +513,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).
- 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 6ef3797..1bfa7da 100644
--- a/docs/PAPER-VALIDATION.md
+++ b/docs/PAPER-VALIDATION.md
@@ -104,9 +104,11 @@ 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.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.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 |
diff --git a/docs/PAPER.md b/docs/PAPER.md
index 9eef365..a54c217 100644
--- a/docs/PAPER.md
+++ b/docs/PAPER.md
@@ -613,7 +613,8 @@ All figures below were measured by the project and are documented in the files c
### 7.2 Drawing
- **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. Small black squares can still show at a dragged window's rounded corners, on the CPU and GPU paths (§10.2).
+- **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.
- 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).
@@ -641,7 +642,7 @@ 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. 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, 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.
### 7.5 Modern PCs
@@ -699,8 +700,8 @@ There are no measurements on real PCs in the repository yet. The ISO is tested o
- Secure Boot must be turned off; signing with a shim is pending.
- 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: small black squares can show at its rounded corners while it moves, on the monitor (fixed in development, not released).
-- Remote desktop: the frames it sends can show a dragged window's rounded corners black.
+- 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 -->
- 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/docs/ROADMAP.md b/docs/ROADMAP.md
index b804f75..a88f446 100644
--- a/docs/ROADMAP.md
+++ b/docs/ROADMAP.md
@@ -572,23 +572,34 @@ LordBench and a desktop that stays smooth under load. Each item is described in
desktop fell to 24 fps under an all-core load:
- [x] The compositor's cgroup CPU weight and its real-time priority (main and paint threads at `SCHED_RR` 2): the
main thread no longer waits for a CPU; 24 → 29–30 fps on the Pi 5.
-- [ ] Black squares at a dragged window's rounded corners (also in 0.8.5): fixed with its own test on branch
- `perf-frame`, not merged yet (still there on `main`, CPU and GPU paths).
-- [ ] The frame-cost work on branch `perf-frame`, not merged yet: steps 0–11 (pixel-identical except the approved
- 1-LSB corner change), the dragged window composited on the GPU ("G0", step 10) with its self-test and
- `LORD_GPU_VERIFY`, LordBench's per-frame phase timing (CPU-late or GPU-late per frame, G0 refusals by cause), G0
- textures catching up in slices, and the paint pool turning on for slow whole frames. Pi 5 with its monitor,
- G0 off: alone 53–58 → 59.8–60 fps, under load 24–25 → 30 fps; with G0 on it stalls (52 fps alone).
-- [ ] Measure that branch on the Pi 5 with the phase timing, then decide G0's default (off with `LORD_G0=1` to turn
- it on, unless the new run shows no stalls).
-- [ ] Build the next frame while the previous flip is pending (today build, GPU and flip run one after another, so
- a 13 ms build plus the GPU's work misses the vblank and the rate locks at 30 fps). Estimated, not measured:
- 30 → 52–58 fps under load. Pixels unchanged.
-- [ ] Step 12: G0 for the whole drag, also where the Dock or the menu bar overlap the window.
+- [x] Black squares at a dragged window's rounded corners (also in 0.8.5, CPU and GPU paths, the remote desktop's
+ frames too): the corner restore on the drag layer now mixes both pixels alpha included (`mix_px` in `canvas.c`),
+ checked against a full repaint by `test_drag_corners` on both paths (`WINDOWS.md`).
+- [x] The frame-cost work (`WINDOWS.md`, `GPU.md`, `BENCHMARK.md` "The drag frame's cost"): steps 0–11, pixel-identical
+ (golden hashes of 2,417 drag frames per path) except the approved 1-level corner change of step 9; LordBench's
+ square and the Cooling fans turn (the `rotate` key); a transformed node repaints when its own style changes; GPU
+ composition without `GL_EXT_unpack_subimage`; the dragged window composited on the GPU ("GPU drag", step 10) with
+ its self-test, `LORD_GPU_DRAG=0` and `LORD_GPU_VERIFY`; LordBench's per-frame phase timing (CPU-late or GPU-late per
+ frame, GPU drag's refusals by cause); GPU drag's textures catching up in slices between frames; the paint pool
+ turning on for slow whole frames; `lord.stats()` in O(1) (a QuickJS patch, `THIRD_PARTY.md`). Pi 5 with its monitor,
+ 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.
+- [ ] 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`, the paper, the FAQ (on the Pi a
- busy app still halves the frame rate) and `THIRD_PARTY.md` (the QuickJS `JS_GetMallocSize` patch).
+- [ ] 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) -->
**Release:**
- [ ] Re-measure the references after the release (results compare only within one LordOS version).
@@ -763,8 +774,9 @@ desktop fell to 24 fps under an all-core load:
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;
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 and the frame's own build time under load, 15–16 ms instead of 7, is what remains to find,
- `BENCHMARK.md` "The desktop under load").
+ 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").
- [ ] **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 4d31e79..5c0072e 100644
--- a/docs/WINDOWS.md
+++ b/docs/WINDOWS.md
@@ -69,6 +69,16 @@ wm.beginResize(id, edges) // edges as in xdg_toplevel.resize: 1 top, 2 botto
shadow are not repainted.
- It is painted in its screen coordinates (a canvas with a shifted origin). That way the terminal
and Linux apps keep recording where they are.
+ - Its rounded corners stay transparent outside the curve (0.8.6, in development). A rounded
+ `overflow: hidden` window saves its corner squares before its children paint and restores them
+ after (`canvas_corners_restore`/`canvas_corners_restore4` in `canvas.c`). The restore used to mix
+ the saved pixel in with `blend()`, which takes its source as opaque, so on the layer's transparent
+ canvas the shadow saved there came back opaque and nearly black: black squares at the corners of
+ every dragged window, on the CPU and GPU paths (0.8.5 and before). It now mixes both premultiplied
+ pixels alpha included (`mix_px`); on an opaque canvas that is `blend()`'s pixel exactly, so nothing
+ else changes. `test_drag_corners` (`engine-test`) drags a rounded window with a shadow over a light
+ box on both paths, with one radius and with per-corner radii, and each corner square must equal a
+ full repaint within 2 levels (before the fix: 217–221 levels off).
- **If something inside changes,** like a terminal line or the blinking cursor, only that part of
the layer is repainted.
- **If a node inside changes** (a style, a text, a transform such as LordBench's turning square, or a
@@ -161,8 +171,10 @@ wm.beginResize(id, edges) // edges as in xdg_toplevel.resize: 1 top, 2 botto
200 %; the last three with boxes and text at half pixels), on the CPU path and on the GPU path's
canvas. Every frame's hash must match
`server/tests/drag_golden_cpu.txt` and `drag_golden_gpu.txt`, written from the code before any change
- to this path and written again at the corner change above (from 001633b plus that change alone): a
- faster frame has to give exactly the same pixels. Before that rewrite every frame was compared pixel
+ to this path and written again at the corner change above (from 001633b plus that change alone) and at
+ the black-corner fix (only the dragged window's corner squares and the Dock's and menu bar's backdrop
+ blur within reach of them changed, compared pixel by pixel first: 498,743 and 445,199 pixels in 2,386
+ of 2,417 frames on the CPU path): a faster frame has to give exactly the same pixels. Before that rewrite every frame was compared pixel
by pixel with the earlier code's: 178,634 pixels in 1,686 of 1,816 frames differed, all by one
level, inside a rounded `overflow: hidden` node's corner squares (`ceil(r) + 1` px) or within the
Dock's and menu bar's backdrop blur reach of one, and none moved away from a full repaint. The hashes
@@ -187,6 +199,11 @@ wm.beginResize(id, edges) // edges as in xdg_toplevel.resize: 1 top, 2 botto
(one level darker in its shadow); before the corners' restore on the drag layer was fixed (black
squares outside the dragged window's rounded corners), 2,217 and 70,882; before the corner change,
2,265 and 70,940.
+- **`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 -->
- **`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/web/content/faq/faq.json b/web/content/faq/faq.json
index 2fef9c9..6fa72ef 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, still short of 60 because each frame takes longer to build under the load, which is still being worked on.",
- "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, todavía lejos de 60 porque con la carga cada cuadro tarda más en armarse, y en eso se sigue trabajando.",
- "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, ainda longe de 60 porque com a carga cada quadro leva mais tempo para ser montado, e isso continua sendo trabalhado."
+ "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 -->"
}
}
]
diff --git a/web/content/features/own-desktop.en.md b/web/content/features/own-desktop.en.md
index 08fa2c9..2ff2f16 100644
--- a/web/content/features/own-desktop.en.md
+++ b/web/content/features/own-desktop.en.md
@@ -65,6 +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) -->
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.
@@ -81,6 +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 -->
- **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 816482b..b626d73 100644
--- a/web/content/features/own-desktop.es.md
+++ b/web/content/features/own-desktop.es.md
@@ -65,6 +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) -->
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.
@@ -81,6 +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 -->
- **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 eab1a7c..93a225e 100644
--- a/web/content/features/own-desktop.pt.md
+++ b/web/content/features/own-desktop.pt.md
@@ -65,6 +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) -->
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.
@@ -81,6 +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 -->
- **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 a4aaf02..3bf2a61 100644
--- a/web/content/paper/paper.en.md
+++ b/web/content/paper/paper.en.md
@@ -456,7 +456,8 @@ All figures below were measured by the project and are documented in the files c
### 7.2 Drawing
- **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. Small black squares can still show at a dragged window's rounded corners, on the CPU and GPU paths (§10.2).
+- **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.
- 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).
@@ -484,7 +485,7 @@ 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. 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, 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.
### 7.5 Modern PCs
@@ -542,8 +543,8 @@ There are no measurements on real PCs in the repository yet. The ISO is tested o
- Secure Boot must be turned off; signing with a shim is pending.
- 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: small black squares can show at its rounded corners while it moves, on the monitor (fixed in development, not released).
-- Remote desktop: the frames it sends can show a dragged window's rounded corners black.
+- 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 -->
- 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 cabff5f..26309ae 100644
--- a/web/content/paper/paper.es.md
+++ b/web/content/paper/paper.es.md
@@ -456,7 +456,8 @@ Todas las cifras de abajo las midió el proyecto y están documentadas en los ar
### 7.2 Dibujo
- **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. Todavía pueden verse pequeños cuadrados negros en las esquinas redondeadas de una ventana que se arrastra, en los caminos de CPU y de GPU (§10.2).
+- **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.
- 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).
@@ -484,7 +485,7 @@ 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. 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, 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.
### 7.5 PC modernas
@@ -542,8 +543,8 @@ La 0.8.0 Beta fue el primer lanzamiento público (18 de octubre de 2026); la 0.7
- Hay que desactivar Secure Boot; la firma con un shim está pendiente.
- 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: pueden verse pequeños cuadrados negros en sus esquinas redondeadas mientras se mueve, en el monitor (corregido en desarrollo, no publicado).
-- Escritorio remoto: los cuadros que envía pueden mostrar negras las esquinas redondeadas de una ventana que se arrastra.
+- 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 -->
- 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 7867238..866dd50 100644
--- a/web/content/paper/paper.pt.md
+++ b/web/content/paper/paper.pt.md
@@ -456,7 +456,8 @@ Todos os números abaixo foram medidos pelo projeto e estão documentados nos ar
### 7.2 Desenho
- **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. Ainda podem aparecer pequenos quadrados pretos nos cantos arredondados de uma janela arrastada, nos caminhos da CPU e da GPU (§10.2).
+- **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.
- 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).
@@ -484,7 +485,7 @@ 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. 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, 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.
### 7.5 PCs modernos
@@ -542,8 +543,8 @@ A 0.8.0 Beta foi o primeiro lançamento público (18 de outubro de 2026); a 0.7.
- O Secure Boot precisa estar desligado; a assinatura com um shim está pendente.
- 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: podem aparecer pequenos quadrados pretos nos seus cantos arredondados enquanto ela se move, no monitor (corrigido em desenvolvimento, não lançado).
-- Área de trabalho remota: os quadros que ela envia podem mostrar pretos os cantos arredondados de uma janela arrastada.
+- 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 -->
- 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.
diff --git a/web/lib/md.mjs b/web/lib/md.mjs
index 9b928d1..ceb66e6 100644
--- a/web/lib/md.mjs
+++ b/web/lib/md.mjs
@@ -4,7 +4,7 @@
// indentation), > blockquotes, ``` fenced code, | tables |, ---, **bold**, *italic*, `code`,
// [links](url), ![images](repo/path.png "caption") and block directives on their own line:
// [[diagram:<id>]] [[shot:<n>]]
-// Raw HTML is never passed through.
+// Raw HTML is never passed through; HTML comments (<!-- … -->) are dropped.
export const esc = (s) => String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
@@ -46,7 +46,10 @@ const cells = (l) => l.trim().replace(/^\|/, '').replace(/\|$/, '').split('|').m
// Returns { html, headings: [{level, id, text}] }
export function markdown(src, opts = {}) {
- const lines = src.replace(/\r\n/g, '\n').split('\n');
+ // HTML comments are notes for editors (e.g. `<!-- PI-RESULT: … -->` where a measurement goes): never
+ // rendered, so one left behind publishes nothing. A comment alone on its line takes the line with it.
+ const lines = src.replace(/\r\n/g, '\n').replace(/^[ \t]*<!--[\s\S]*?-->[ \t]*\n/gm, '')
+ .replace(/[ \t]?<!--[\s\S]*?-->/g, '').split('\n');
const out = [];
const headings = [];
const used = new Set();