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.

233 KB
Raw Blame

Changelog

All notable changes to LordOS are documented in this file.

The format is based on Keep a Changelog, and LordOS adheres to Semantic Versioning. Pre-releases carry a suffix (-beta) and are published on GitHub as pre-releases. Each section below is also the body of the matching GitHub release, generated by tools/release/release-notes.sh (see docs/RELEASING.md).

Unreleased

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 marking where the final Pi 5 run's numbers go, each next to a sentence that is true without them (all filled after that run on 2026-10-29, the first entry under Changed). The site's Markdown renderer (web/lib/md.mjs) now drops HTML comments, so a marker left behind is never published. THIRD_PARTY.md lists the QuickJS JS_GetMallocSize patch as a table row.

  • Docs (2026-10-28): FANS.md no longer says the Cooling fans turn in this build (the transform key the 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).

  • The 0.8.6 plan (2026-10-28): docs/ROADMAP.md has a "Release 0.8.6 (in development)" section listing what is built and what is left for LordBench and for the desktop under load on the Pi 5.

  • The 0.8.7 plan (2026-10-29, decided by the maintainer): LordBench's x86 PC reference (a modest PC still to be chosen) and hardware video decoding (VA-API on PCs, the Pi 5's HEVC decoder) move from 0.8.6 to a new "Release 0.8.7 (planned)" section of docs/ROADMAP.md, next to the community hardware reports. BENCHMARK.md, PAPER-VALIDATION.md and the paper (§7.5; en, es, pt) say so.

  • 0.8.5-beta published (2026-10-27): the GitHub release carries the live ISO, the Raspberry Pi 5 image (lordos-0.8.5-rpi5-arm64.img.xz, the LordOS kernel 6.18.57-lordos.3 for the Pi 5; the Pi 4 still boots Raspberry Pi's archive kernel), the amd64 and arm64 packages with their SBOMs, install.sh and the three desktop downloads of LordOS Imager 0.8.5 (the universal build, signed and notarized; the 64-bit installer; the Debian package). The Imager 0.8.5 is the first desktop build that reads point releases (v0.8.4.1-beta) in its app update check and its release list. SHA256SUMS (11 files) is signed with the release key. The site's downloads (lordos.media) now point to 0.8.5.

Added

  • LordBench, first part (in development for 0.8.6; docs/BENCHMARK.md, "Built so far"): System Information has a Performance tab with a Quick test (less than a minute) and a Full test (adds storage and three minutes of sustained load). The work runs in lord-bench, a new sandboxed helper launched by lord-server like lord-doc and lord-media (its own folder only, no arguments, sandbox_apply_helper before any work, scope lordos-bench.scope, 2 GB cap), which gets only the GPU's render node and an unnamed scratch file opened by lord-server and answers only with fixed-size records lord-server checks.

    • Workloads, each the median of three runs with its spread, on one core and on all:

      • SHA-256 and a 256×256 matrix product;
      • the package engine's xz decoder on a fixed 2 MB text generated at build time;
      • QuickJS running a fixed script;
      • LordOS's own interface work (bench/lbui.c, the engine's real code linked into lord-bench): layout and paint of a fixed 1920×1080 scene built in C (529 nodes: a translucent top bar, a file manager with a 40-row list, a settings window with a wrapped paragraph and controls, a notification and the Dock with backdrop blur, shadows, a rotated badge, a half-transparent card), every node invalidated and the whole screen painted each frame, in frames per second (cpu.ui.1; cpu.ui.n is the same with the paint's row bands on up to 8 threads, as lord-server's paint threads); and shaping fixed paragraphs in Latin, Arabic with embedded left-to-right text, Devanagari, Thai and Chinese with kana (bench/lbtext.h) as the engine's text layout does (bidi, script runs, each character's font, GSUB and GPOS, the visual order), in runs per second, one core and all (cpu.shape.1/n). The helper opens no files: the scene is fixed data and the fonts are built into the binary (build/gen/lb_fonts.h): LordOS's Inter and Debian 13's Noto Sans Arabic, Devanagari, Thai and CJK SC subset to exactly those paragraphs with every layout feature kept (tools/gen-lbfonts.py, committed in server/src/bench/fonts with their OFL licence; Inter pinned by its SHA-256 in mk/lordbench.mk, so a new Inter fails the build until the references are measured again); build/shape-test gives the same glyph positions with each subset as with the full system font, though the subsets shape about 12 % faster than the full fonts (fewer lookups), so the workload is comparable only with itself. These four numbers measure LordOS's engine with the machine: a reference value of one carries the LordOS version it was measured with and gives a "×N" only to a result of that version (ENGINE_IDS in apps/sysinfo/perf.js). The paint threads of cpu.ui.n start each run from a clean pool, and the shaping threads only read the shared script table (set before they start; ThreadSanitizer had found a race there). lord-bench grows from 1.48 to 2.42 MB of code; its sandbox, seccomp list and fds are unchanged;
      • memory copy and triad bandwidth and a 64 MB pointer-chase latency;
      • OpenGL ES 2 offscreen at 1920×1080 on the render node: the 3D scene, fill rate, texture upload and 8 layers;
      • (Full only) sequential write and read and random 4 KiB reads on up to 1 GB;
      • (Full only) a sustained all-core load sampled every 10 s with the temperature.
    • Guards, read by lord-server:

      • refused on battery below 30 %;
      • waits for a quiet CPU, at most 30 s; otherwise the run is marked busy;
      • stops within 2 °C of the passive trip point (10 °C of the critical one without one);
      • the peak tests also stop when the x86 throttle counters grow or the Raspberry Pi firmware reports throttling;
      • in the sustained test, throttling is recorded with its time and temperature instead.
    • Helper-sandbox self-test (sec.helper-sandbox, repeated inside lord-bench): right after sandbox_apply_helper and before any work, lord-bench tries six things that must fail, the Sandbox Probe's helper tries plus two: a unix socket, an internet socket, exec, fork, a new file (O_TMPFILE in /tmp) and reading /etc/passwd. None could change anything if it worked (exec is called with an invalid environment pointer, so an allowed one fails with EFAULT before anything is replaced; a socket or unnamed file is closed at once; a forked child only exits). Each try is a fixed record (LB_MSG_SANDBOX, checked by lb_msg_valid), the result lists them as sandboxTries (id, refused, errno), the Stability verdict fails a run where one got through or is missing (naming each try in the user's language, "run a program", …) and otherwise says that all six were refused; on a kernel without Landlock the two file tries only warn, since the sandbox mask already records that limit. lordos-sysreport bench checks the same six by name ("N of 6 tries refused", a NOT REFUSED line for each one that worked or is missing) and exits with 3 when one got through. On VM 116 all six were refused (EPERM from seccomp for the sockets, exec and fork; EACCES from Landlock for the files), and a trace of a run shows the CPU workloads open no file.

    • Results: shown as "×N" of each reference machine per category, never one score, with three verdicts:

      • performance;
      • compatibility, from the Compatibility tab;
      • stability: stops, failed measurements, throttling, under-voltage, a sustained drop, a busy start and the helper-sandbox self-test.

      Each result also shows the change against the previous run and the conditions that differ, every recorded condition, the boot time per LordOS version and Save to Documents. Nothing is sent anywhere.

    • Recorded conditions: temperatures and trip points, power, governor, platform profile, GPU kind, disk kind, composition and display modes. No names or identities.

    • Video: a lord-media job (MK_VBENCH, media/helper/lm_vbench.c, launched by bench/lbvideo.c with no fds) generates its own test clips in memory from a fixed synthetic picture (H.264, HEVC, VP9 and AV1 at 1080p; H.264 and HEVC at 4K) and decodes each in software the way the player does, as frames per second; then the remote desktop's own encoders (lm_stream_sw_encoder: H.264 and VP8) encode 1080p frames. Quick measures H.264 1080p and the H.264 encoder. lord-media answers only MM_BENCH records, checked by lbv_record_valid. Hardware decoding is not measured (neither test machine has it).

    • Desktop impact (its own button and result file, lordbench-desktop.json): System Information opens a scene window and lord-server moves it along a figure of eight through the drag's own path (lord.wm.script, grab_script_begin in ui/grab.c, no JS per frame; wm.scriptMove/wm.stopScript in the SDK). lord-server records every frame it builds and every frame the display shows (bench/lbframes.c): 10 s alone, then 10 s while lord-bench loads every core at the lowest priority (LB_MODE_LOAD, nice 19, idle I/O). Each phase gives frames per second, the time to build a frame (median, 99th percentile) and the share of late frames (intervals over 1.5 refresh periods); the verdict compares the 99th percentile with the refresh period in use and warns above 5 % late (problem above 25 %). Frame times never come from a helper: lb_msg_valid refuses ids past LB_HELPER_LAST.

    • Boot time test (Performance → Boot time, administrators): 3, 5 or 10 boots in a row. The closed admin action boot-test <2..10> writes /var/lib/lordos/boot-test in a fixed format (bench/boottest.c) and boot-test-cancel (anyone) removes it; the session restarts as usual. At each boot's first frame lord-sessiond records the boot with its number in the test and, while boots are left, restarts 30 s later. The login screen shows the boot and the countdown with Stop the test, and a login stops it too. The count only goes down, a state older than 30 minutes is discarded, and the action is refused in the live session. The Boot time group shows each version's latest test (median and range). Checked by unit tests; not yet run end to end on a machine.

    • References: VM 116 (8 vCPU Xeon Silver 4108, llvmpipe) and a Raspberry Pi 5 16 GB (SD card, V3D), each a real Full run (apps/sysinfo/references.js):

      • VM 116: SHA-256 166/984 MB/s (one core/all), matrix product 3.3/19.9 GFLOP/s, memory copy 20.0 GB/s; software decoding H.264 1080p 399 fps, AV1 1080p 201 fps, HEVC 4K 102 fps; H.264 encoder 106 fps. The interface workloads, from a later Full run (2026-10-28): layout and paint 37.0 fps on one core and 39.9 fps with the paint threads (a frame is about 28 ms, almost all of it paint: the layout of the 529 nodes takes 0.15 ms, and only big row-local fills, shadows and blits are split into bands); shaping 619 runs/s on one core and 3,595 on eight. A Quick run from a terminal now takes 46 s. The Pi 5 has not been measured with them yet (its reference lists them as not measured).
      • Pi 5: SHA-256 933/3,693 MB/s, matrix product 2.26/5.99 GFLOP/s, memory copy 7.6 GB/s, latency 115 ns; V3D scene 795 fps, fill 2,455 Mpixel/s; SD card 66 MB/s write, 91 MB/s read; 3 minutes sustained at 5.86 → 5.88 GFLOP/s with the fan, 55.6 °C at most; software decoding H.264 1080p 258 fps, AV1 1080p 159 fps, H.264 4K 55 fps, HEVC 4K 57 fps; H.264 encoder 75 fps. Quick takes 34 s, Full 339 s.
    • Desktop impact measured on the Pi 5 with a 1920×1080 60 Hz monitor and GPU composition: alone 59.4 fps, frame build 10.9 ms median and 13.0 ms p99, 1.0 % late; under the low-priority all-core load 24.0 fps, 20.1/29.3 ms, 96.5 % late. A stability problem found by LordBench; its cause and the fix are under Fixed ("The desktop under load").

    • Pointer to screen (desktop test): a synthetic pointer in lord-server (bench/lbinput.c) plays a 125 Hz mouse that moves the scene's window: each event is stamped when it is made and announced on an eventfd the main loop polls like an input device, the main loop applies the newest position once per frame as it does with a real mouse, and each event's latency ends when the first frame showing it is presented (bench/lbframes.c). Median and 99th percentile alone and under load (comp.in50/in99, desk.in50/in99); the verdict warns above three refresh periods. It measures lord-server's part, not the mouse's; the positions only move LordBench's own window. VM 116 without a monitor: 14.6/25.2 ms alone, 15.1/30.9 ms under load. Pi 5 without a monitor: about 16/27 ms alone, 22/52 ms under load.

    • lordos-sysreport bench [--quick | --full] [--json]: LordBench from a terminal, over SSH or in CI, through lord-server's own code (bench/lbrun.c): the same guards, helpers and result file, which System Information then shows. lordos-sysreport is now installed in /usr/lib/lordos/bin with /usr/bin/lordos-sysreport and lordos-fetch as links (tools/iso/mkdeb.sh), because the helpers are only started from next to their own binary. A quick run took 39 s on VM 116 (46 s with the interface workloads). On VM 116 (headless, with a remote viewer) 59.6 fps alone, p99 13.3 ms; p99 22.9 ms and 12.5 % late under load.

    • Boot measured: the Pi 5 reaches the login screen on its monitor 5.99 s after the kernel starts (systemd: 2.1 s kernel + 4.2 s userspace).

    • Pi limitation: the LordOS Pi kernel exposes neither the firmware's get_throttled nor a cpufreq cooling device, so the firmware's own flags can't be seen there (the under-voltage alarm is read); the sustained curve and the temperature are the evidence instead, and the firmware's documented 80 °C limit now counts as throttling (next item).

    • The Raspberry Pi firmware's throttling during a run (bench/lbcond.c, bench/lbrun.c; docs/BENCHMARK.md, "The Raspberry Pi firmware's throttling"; tested on fake sysfs trees and VM 116, and on the Pi 5 on 2026-10-29: piFirmware {"flags": false, "voltageAlarm": true, "underVoltage": false, "tempLimit": false, "tempLimitC": 80}, the alarm 0 before and after the run with the official supply). Checked in Raspberry Pi's rpi-6.18.y source, the kernel LordOS ships: drivers/firmware/raspberrypi.c has no get_throttled file any more, and the rpi_volt hwmon (drivers/hwmon/raspberrypi-hwmon.c, a module in bcm2712_defconfig) asks the firmware every 2 s with the sticky bits cleared and exposes only in0_lcrit_alarm (0444), "under-voltage in the last 2 s"; the capped, throttled and soft-limit bits are not exposed without the mailbox, which LordBench never opens. So lord-server now: reads the alarm strictly (0 or 1); still reads get_throttled where an older kernel has it, strictly (1-8 hex digits, optional 0x, rpifw_parse_throttled, masked to bits 0-3 "now" and 16-19 "has occurred"; anything else is unknown instead of being half-parsed); knows a Pi from that hwmon, that file or the device tree's raspberrypi, compatible; and on a Pi counts the hottest zone at or above 80 °C as the firmware's limit (Raspberry Pi documents progressive Arm throttling from 80 °C; the Pi 5's thermal zone has no passive trip, so before this the guard waited for 100 °C). Every guard sample of the run (once a second) is accumulated (lb_rpi_watch): "now" bits and the 80 °C limit always count, while a sticky bit or alarm already set at the start counts only after it was seen clear and set again, so an event from before the run is never blamed on it. Before, the alarm and the bits were only looked at in the start and end snapshots, so an under-voltage in the middle of a run was lost. In a peak test, capped, throttled, soft limit or the 80 °C limit stop the run as throttled (like the x86 counters); in the sustained test the first one is recorded as throttleAtS/throttleTempC; under-voltage is never a stop and is recorded on its own. A result on a Pi carries piFirmware (flags, voltageAlarm, underVoltage, capped, throttled, softLimit, tempLimit, tempLimitC; what could not be read is left out, not false), and before/after add rpiUnderVoltageAlarm. System Information → Performance: the Stability verdict uses piFirmware for "The board reports throttling", a new "It reached 80 °C, where the board's firmware starts slowing the processor down" and "The board reports low supply voltage" (older results keep the end's bits), and Conditions has a new Board firmware row (en, es, pt). Machines that are not a Pi are unchanged.

    • Tests: tests/lordbench_test.c (records, workloads, fake sysfs trees of an x86 laptop and a Pi 5, boot history, the frame recorder and its pointer latency, the synthetic pointer's thread and eventfd, the video records, the boot test state file, the interface scene with every style key known, each paragraph shaped with no missing glyph and the same twice, the sandbox self-test's records, the Pi firmware's flags and alarm on a Pi 5 with LordOS's kernel, a Pi known from its device tree and an older kernel with get_throttled, and the strict get_throttled parser; 1,198 checks) and tests/sysinfo_perf_test.mjs (62 checks, with the desktop verdict, the pointer latency notes, the video category, the self-test in the stability verdict with and without Landlock, the engine workloads compared only within one LordOS version, and piFirmware in the stability verdict).

    • Not built yet: hardware video decoding and the x86 PC reference.

  • Flatpak and Flathub design review, kept for the future (docs/FLATPAK.md, no code; the maintainer decided on 2026-10-27 not to implement Flatpak for now, to keep the system stable, and it is not planned for any release): a launcher-owned scope per Flatpak app so the 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 window with a shadow, a turning 72 px square and six cards with shadows and text, a rounded window below, a menu bar and a Dock with backdrop blur, on a 1024×640 display) dragged along LordBench's figure of eight (lbi_path) for 480 frames, painted as main.c paints a frame, plus four 60-frame runs for what makes the layer paint again (a text that changes a child's size, a child moving inside the window, a terminal's blinking cursor, a square turning across the window's edge). Each of the 725 frames is hashed (FNV-1a over the pixels) on the 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: 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 (the square turns every 10th frame), then the square turning again at frame 40; and k2, the whole drag on a 2048×1280 display at 200 %. These three add a column of boxes with odd widths, shadows and text centered at half pixels. Their 183 hashes per path were written by make drag-golden on 001633b's code (the four functions the test calls that 001633b lacks, node_restyled, paint_root_clear, paint_root_full and paint_layer_parts, added beside it unchanged or as a no-op count; the first five runs' 725 hashes came out identical to the committed ones, which checks that), and the current code passes all 908 on both paths. Each run catches a change the first five miss (checked by breaking the code on purpose): partial repaints across x = 0 (neg, 42 of 61 frames), a node's part trusted after outside damage mapped through a stale layer.at (remove, 20 frames from frame 40) and a part's box computed without the display scale (k2, 59 frames). The whole of engine-test takes about 15 s on VM 116 (11 s before).
    • LORD_PAINT_VERIFY=N (lord-server's environment): every N-th frame of each display is compared with a full repaint of the tree into a scratch canvas (paint_root_full: no drag layer, no copy of what is below it, no skipped node; the GPU path's list of app windows is kept), and the count of differing pixels goes to stderr. Off by default.
    • 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. The first phases on a GPU came from the Raspberry Pi 5 with its monitor (V3D, 1920×1080, 2026-10-29; p50/p99 in ms). With the frame pipeline and GPU drag off (the defaults now): alone renderMs 8.15/11.57 (paintMs 6.31/9.56, uploadMs 1.41/1.72, 0.971 Mpx a frame) and gpuMs 1.51/1.57; under load renderMs 13.25/18.92 (paint 8.55/13.11, upload 4.24/5.25) and gpuMs 14.49/19.00, and of 374 frames 39 on time, 14 CPU-late and 320 GPU-late. With the pipeline off and GPU drag on: under load render 13.20/18.25, GPU 14.19/18.25, 23 on time, 15 CPU-late, 327 GPU-late of
    1. With the build's defaults then (the pipeline while frames are heavy, GPU drag on): under load render 13.85/19.07, GPU 15.63/23.38, heldMs 18.27/31.60, 148 on time, 1 CPU-late, 285 GPU-late of 436. So under load the frame is late on the GPU's side: its time per frame goes from about 1.5 ms alone to 14–16 ms.
  • Automatic default apps (in development for 0.8.6; docs/SETTINGS.md, "Default Apps"): when you never chose an app for a file type, a file of that type still opens. Before, lord.apps.launchWith('', path) only read the [Default Applications] lines of the mimeapps.list files and, on a fresh account with none, nothing opened (Files opened an .html in the Text Editor, and anything that asks for "the default app" got nothing). Now apps_default_for() (server/src/apps.c) follows the freedesktop MIME Applications order: the user's own [Default Applications] (an explicit choice), then what the system marks as default (/etc/xdg/mimeapps.list, /usr/local/share/applications/mimeapps.list, /usr/share/applications/mimeapps.list, defaults.list), skipping entries that aren't installed, then [Added Associations], then the first installed app whose MimeType declares the type, in mimeinfo.cache order and then by desktop id (deterministic); [Removed Associations] are honoured, MIME subclasses and aliases are not followed. Only apps the launcher itself runs count: a .desktop in /usr/share/applications or ~/.local/share/applications that it lists (not Hidden, NoDisplay or Terminal, TryExec found, OnlyShowIn/NotShowIn) with a MimeType and an Exec that takes a file (%f %F %u %U) and names a program that exists. No path, argument or way to write .desktop files was added; the file still goes through launchWith's checks (a real path in the home or the user's mounts, one argument, no shell). lord.mime.resolve(mime) returns { id, explicit, source } and lord.mime.unset(mime) goes back to automatic (removes the user's line from [Default Applications] and [Added Associations] of ~/.config/mimeapps.list, every other line kept, as GLib's reset does). Settings → Default Apps shows a category you never chose as "Automatic ()" ("Automática (…)", "Automático (…)"): the system's default, else LordOS's own app for it, else the first installed app that declares the type; an explicit choice can go back with "Automatic". Files' default (defaultOpenerId) uses the same order, so on a fresh account an .html file opens in the installed browser. Tests: build/defaults-test (38 checks, in make -C server test) over a fake XDG tree: the user's choice wins (also lordos-<app>.desktop, left to the theme), the system's lists in order with uninstalled entries skipped, the first declaring app by id and by mimeinfo.cache (the user's first), Hidden/NoDisplay/Terminal/OnlyShowIn/a missing TryExec/an Exec without a file code or with a missing program skipped, ids outside the launcher's folders ignored, [Removed] and [Added Associations], going back to automatic, no app → nothing, and that launchWith('') really starts the chosen app with the file. Checked on VM 116 in an isolated headless session with a fresh home and no mimeapps.list (2026-10-29): Settings → Default Apps showed "Automatic (Chromium Web Browser)" for the web browser and "Automatic (Mail/Player/Photos/PDF Viewer/Text Editor)" for the rest; choosing Chromium wrote the four browser types, "Automatic" removed them again; double-clicking page.html in Files opened it in Chromium (the only installed app that declares text/html there).

Changed

  • The frame pipeline and GPU drag are off by default, after the final Raspberry Pi 5 run (2026-10-29, in development for 0.8.6; docs/BENCHMARK.md, "The drag frame's cost"; docs/GPU.md). The Pi 5 16 GB with its 1920×1080 60 Hz HDMI monitor, the LordOS kernel 6.18.57-lordos.3, an autologin session and the arm64 build of this branch; LordBench → Desktop impact, "under load" = all four cores busy at the lowest priority:

    Configuration Runs Alone fps Pointer to screen p50 alone Under load fps Late under load Pointer to screen p50 / p99 under load
    Pipeline while frames are heavy, GPU drag on (the build's defaults then) 2 60.0 42.1–42.5 ms 33.0–36.2 65.8–81.6 % 77.3–79.8 / 98.7–99.8 ms
    LORD_PIPELINE=0, GPU drag on 3 59.9 25.5–25.7 ms 30.8–31.6 87.3–94.3 % 48.8–49.0 / 66.1–79.4 ms
    Both off (the defaults now) 2 59.9 25.7–25.9 ms 30.5–31.1 89.5–96.2 % 48.5–49.0 / 66.3–80.6 ms
    • LORD_PIPELINE is now off unless set to 1 (while frames are heavy) or 2 (always): it gave 2–5 frames a second under load but 17 ms more pointer latency alone and 29 ms more under load, and its auto mode engaged even alone at 60 fps. The code stays; the session log says lord-server: frame pipeline off (LORD_PIPELINE: unset or 0 off, 1 while frames are heavy, 2 always).
    • GPU drag is now off unless LORD_GPU_DRAG=1, and its self-test runs only then: it is correct on V3D (its self-test passes, 11,373,321 pixels in 341 ms; LORD_GPU_VERIFY=1 compared 138 frames, all equal) but gave no measurable gain (30.5–31.1 fps under load off, 30.8–31.6 on; it composed about one frame in five). The log says gpu: GPU drag off (LORD_GPU_DRAG=1 turns it on): the dragged window is composed by the CPU.
    • With both off the frames are the ones measured in the last row; the goldens are unchanged. So on the Pi 5 an all-core load still takes the desktop from 60 to about 31 frames a second. What remains is the GPU's time per frame: 1.5 ms alone, 14–16 ms under load (frames.phases: 320 of 374 frames GPU-late), and the upload of about 1 Mpx a frame from 1.4 to about 4 ms, while vcgencmd every 2 s showed V3D at 0.86–1.15 GHz, the ARM cores at 1.8–2.4 GHz, 36.7–47.2 °C and get_throttled=0x0 throughout: no clock or thermal throttling. Most likely memory contention with the load; not proven (no memory-bandwidth counter was read). Next: fewer pixels uploaded and composed per frame (a buffer-age scissor, PBO uploads) and finding what slows V3D under CPU load (ROADMAP.md).
    • In the same run: the firmware's power alarm (System Information's and LordBench's reader, hw/rpifw.c) is present on the Pi 5's LordOS kernel and reads 0 with the official supply (piFirmware: voltageAlarm true, underVoltage false; in0_lcrit_alarm 0 before and after); the dragged window's rounded corners are clean on the monitor (no black squares, over a window and over the wallpaper; docs/WINDOWS.md); lordos-sysreport bench --quick (two runs): cpu.ui.1 39.3–39.4 fps, cpu.ui.n 45.4 fps, cpu.shape.1 630–632 runs/s, cpu.shape.n 2,522–2,527 runs/s (docs/BENCHMARK.md).
    • Checked on VM 116 with the new defaults: make -j8 with no warnings; make test: 23 passed, 0 failed, 13 skipped; engine-test: 6,907 checks, 0 failures, drag_golden_{cpu,gpu}.txt unchanged; fpipe-test: 61 checks (unset, 0, an empty or any other value off, 1 while frames are heavy, 2 always; the auto mode's tests now ask for 1); lordbench-test: 1,217 ok.
  • The desktop under load, third step: a cheaper frame while a window is dragged (in development for 0.8.6; docs/BENCHMARK.md, "The drag frame's cost"; docs/WINDOWS.md; docs/GPU.md). Steps 0–11 (the next two entries), GPU drag (the third) and the Fixed entries for the black corners, the rotated node's repaint and 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; the final run with everything in this list (2026-10-29) has its own entry at the top of Changed: with the frame pipeline and GPU drag off, the defaults now, alone 59.9 fps (build p50 8.03–8.13 ms, p99 11.42–11.57 ms, 0.17 % late, pointer to screen p50 25.7–25.9 ms) and under load 30.5–31.1 fps (build p50 13.15–13.25 ms, 89.5–96.2 % late, pointer to screen p50 48.5–49.0 ms, p99 66.3–80.6 ms).
    • Checked on VM 116 at the frame pipeline's commit: make -j8 and lord-server with GPU=0 (no EGL, GBM or GLES linked): no warnings; make test: 23 passed, 0 failed, 13 skipped; engine-test: 6,883 checks, 0 failures (the 2,417 golden frames per path, the gpu-drag path and the pipelined drag runs); fpipe-test: 39 checks; 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 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). A third time, on the GPU path only, when this work was rebased onto the partial-repaint fixes (Fixed, "Partial repaints that left stale areas"): their rule that a blurred surface is repainted with the margin its blur samples (blur_near) changed frame 0 of three runs (neg, mix, k2mix), where the first dragged frame's damage reaches the menu bar's or the blurred panel's margin, and nothing else. With that one rule reverted every one of the 2,417 hashes matched the old file; the CPU path's file is unchanged; those three frames differ from a full repaint by at most 2 levels (1,596, 8,778 and 40,180 pixels; 1,532, 8,400 and 38,099 before). 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 itself cleared to the same black before it was painted, so the GPU path's app-window holes stay the same.
    • lord.stats() no longer walks every JavaScript object: jsKB comes from JS_GetMallocSize, a local QuickJS addition (THIRD_PARTY.md) that returns the same malloc_size JS_ComputeMemoryUsage reported (checked equal on a runtime with 100,000 objects, a 50,000-entry Map and after GC). About, Settings → General and System Information poll it while they are open.
    • Only the changed part of the dragged window's layer is painted again: a node inside the window that changes (a style, a text, a transform such as LordBench's turning square, a child moving inside) now repaints only its old and new boxes in the layer, with a 4 px margin (layer_tree_part in ui/paint.c), instead of the whole window and its shadow. The layer is still painted whole for the window's own style or size, a part outside the layer or bigger than half of it, and whenever the result can't be shown to be the same: the window moved by a fraction of a physical pixel, the layer's box would change, a fractional display scale, positions or sizes that aren't sixteenths of a pixel within ±4096 px, fractional font sizes, text drawn through textlayout.c or in a font whose em isn't a power of two of at most 2048 units, as Inter's is (text_drew_inexact), an unchanged transformed node, an app window or a video inside (layer_part_exact, layer_note_exact). A transformed node's image steps its bilinear weights from the first pixel of each row, so a part cutting it on the left would change them; canvas_affine_watch/canvas_affine_cut (canvas.c) report that and the layer is painted whole. In test_drag_exact's first five runs 366 of the 611 layer renders are now parts (before: 6, the terminal's), and 438 of 738 with the three runs added later. Every golden hash is unchanged on both paths. With neither the margin nor the watch, 160 frames per path fail; with the watch but no margin, they all pass.
    • GPU path: no app-hole walk for a window without app windows, and a faster sentinel fill (ui/paint.c). The layer's hole map now carries a flag, layer.has_holes, that is 0 only while the map stands for all zeros; then layer_holes only turns the sentinel back into 0 (it no longer writes zeros over zeros) and layer_paint skips the per-pixel walk that reopens app holes over the blit, which for a window with no app surface never wrote anything. The flag is recomputed from what a whole-map pass wrote, a part pass can only raise it, and a part that brings the first hole into a map that had none zeroes the rest of the map first, so the map is byte for byte what the old code would have read. layer_fill fills one row with the sentinel and copies it to the others. Checked: the golden hashes (GPU path), and a differential run of the frame against 001633b's paint.c with an app window inside the dragged window (half of it an alpha-0 hole), present from the start and removed at frame 60, or appended at frame 40, identical on both paths over 3,874 frame hashes; with the walk always skipped, 139 of them differ.
    • A setStyle that only turns or scales a node no longer lays that node out again (node_restyled in ui/node.c). When the only change is rotate, scaleX, scaleY or transformOriginX/Y (what runtime/style.js makes of a transform), the node already had its StyleExt, it isn't a text node and has no text node above it, and its subtree has no text or image (at most 256 nodes), the node is marked for repaint and placed again by its parent (node_moved) instead of node_invalidate: its own layout pass and the measure flags are kept. That gives the same layout by construction: layout never reads the transform, place() computes every node's matrix on each layout_root, the measure flag is read only by text nodes, and a subtree without text or images lays out from styles and sizes alone. Its ancestors are still laid out again, as before, so the saving is only that node's own pass (small: LordBench's square has one child). setStyle(n, 'transform', …) is still not a key lord.setStyle takes and still changes and marks nothing. Checked by test_transform_restyle (engine-test): two copies of a tree, one through node_restyled and one through node_invalidate, 120 frames of turns and scales on five nodes (a leaf, one with boxes inside, one with text inside, one under a text node, one sized by flex) mixed with a column width moving by 0.3 px, a font size and a root width moving by 0.2 px: every node's box, absolute position, matrices and text measure, and every pixel, are equal; the 'transform' key changes nothing. The golden hashes are unchanged (the drag's square now takes this path) and the frame against 001633b's f_set_style logic is identical in the differential run.
    • The JS timers no longer look at every pending timer on each pass of the main loop (ui/js_prelude.h, the polyfills moved out of ui/js.c unchanged otherwise). __lordTick keeps the earliest deadline (minAt, lowered by every setTimeout/setInterval/setImmediate) and returns at once when nothing is due; when something is, one pass collects the due timers without building an [id, timer] pair per timer and computes the next deadline. Due timers still run by deadline, then by id, each at most once per tick, a timer set during the tick waits for the next one, and one cleared before its turn doesn't run. Clearing the earliest timer marks minAt stale and it is computed again before it is used, so the wait the tick returns to the main loop is the same number, not only the same order. lord-server also makes the atoms of __lordTick, __lordWantsFrame and __lordFrame once per runtime (call_hot) instead of on every call; the function is still looked up each time, so the recovery screen's replacements are the ones run. Checked by build/timer-order-test (make -C server test): 400 seeded random scripts run on this prelude and on 001633b's, in QuickJS, with timeouts, intervals and immediates at equal, zero, negative, fractional, NaN and string delays, clears of pending, due, fired, unknown and string ids, timers set and cleared from inside callbacks, callbacks that throw, and ticks whose now is behind the clock lord.now() reads (a clock that moves on every read, so both must also read it the same number of times): 427,538 callbacks and 21.6 MB of trace (what runs, in which order, with which arguments, every value the tick returns as %.17g, and what is logged) are identical. Breaking the code on purpose fails it: firing by id alone, 400 of 400 scripts differ; not recomputing after the earliest timer is cleared, 397. A tick with 200 timers pending and none due: 158.75 µs before, 0.30 µs now (build/timer-order-test bench, VM 116, x86_64).
    • Fewer React renders and style conversions that change nothing (runtime/index.js, apps/sysinfo/performance.jsx). applyProps keeps, per node (a WeakMap, so the instance a ref sees is unchanged), a copy of the flattened style it last converted, as keys and values in their order, and only when every value is a primitive and no converted value is NaN. A render whose flattened style has the same keys in the same order with the same values (Object.is) skips normalize and applyStyle: normalize is pure (no direction, theme or state), so it would give an equal style and applyStyle would send no call. A style object changed in place is still seen (the copy is compared, not the object), a different key order is not skipped (later keys override earlier ones: margin then marginTop), and a NaN (a bad #zz color, a gradient without an angle) keeps the old behaviour of re-sending that property on every render. Object values (a transform list) are never skipped. LordBench's Performance view no longer re-renders on a 500 ms poll that brings the same state, mode, step and progress as the last one (a result or a start error always counts as new). Checked by tests/runtime_props_test.mjs (make -C server test; needs node and node_modules, so it is skipped on VM 116, which has no node): fuzzed trees of 24 nodes (views, texts, images, an Activity that hides and shows half of 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 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 instead of 356 applyProps calls. No C code changed; the golden hashes and engine-test pass as before.
    • What is below the dragged window is painted again only where it changed, and copied where the old rule painted everything (below_ready in ui/paint.c; step 11, after the corner change in the next entry). The copy of what is below the window was built whole on any change outside the window, and two changes within 8 frames stopped it for the rest of the drag, so a progress bar below or the menu bar's clock made every frame paint the whole damaged box again (LordBench's Performance view polls every 500 ms; each render commits twice). That rule is kept as a shadow, and on top of it:
      • damage_walk knows the paint order around the window (below_order: the children of each of its ancestors, stable by zIndex; anything unknown counts as before it), so a change painted after the window no longer touches the copy. A change painted before it, and any damage from outside the tree, mark their boxes stale (DamageList, built as up to four rectangles), and only those are painted again (below_update), each one grown first to the whole reach of a backdrop blur it touches (the blur reads twice its radius around its box and starts its grid at the clip) and to the whole image of a turned or scaled node (canvas_blit_affine steps its rows from the first painted pixel), with the blurs and images the last build met; after the build the same check runs with the ones it met now, and the copy is built whole if a part was not closed. The copy is built whole when the order around the window changes (a signature of those children), the display's view or size changes, or the stale part is more than half the screen.
      • A frame where the old rule painted everything uses the copy anyway (below_switch, paint_below_switch) when that gives the same pixels: the canvas was to be cleared to black; no blurred node before the window meets the frame's box; no turned or scaled node before it meets the box with its image starting left of it; no border strip or rounded-corner square of one of the window's ancestors meets it (those are painted after the window, so over the copy they would be painted twice); the last build reached the window; and the stale part costs less than the box.
      • The old rule decides when the copy is rebuilt, so the pixels are the same as before (step 9's corners aside): damage from outside the tree inside the window's boxes (a Linux app under the window's shadow) still keeps the old copy until the old rule rebuilds it, and is repainted then. A frame uses the copy only when the window is drawn and untransformed (no transform, every ancestor shown and visible), the copy's builds walk every node (LORD_DAMAGE=multi's cull is off for them), and a hidden window's copy is always built whole.
      • main.c's drag: … line ends with below: … built whole, … in part, … frames switched to it (not: … ancestor, … blur, … transform, … unreached, … cost), and LordBench's scripted move writes the layer's counters and the same text in a drag (scripted): … line when it ends, for the Pi's session log.
      • Checked on VM 116 (x86_64): test_drag_exact has nine more runs, 1,500 frames per path (a progress bar in the window below changing width every 3 frames and its title every 30, with an app window and a blinking terminal in it; the menu bar's text every 2 frames; a square turning on the desktop and one turned and still; a blurred panel whose clock changes every 40 frames; the window below raised above the dragged one and back; all of them at 100 % and at 200 %; both windows inside a rounded container with a border; a dot changing color on the still square), whose hashes were written from e24af69 plus the corner change, with the GPU path's list of app windows hashed with the pixels (the test's wl_paint now keeps that list as wl.c does and opens the holes); the earlier 908 hashes per path are unchanged. All 2,417 frames per path match. 591 frames per path use the copy where the old rule painted everything (refused: 30 for an ancestor, 358 for a blur, 153 for a transform), and each of them is painted the old way on a copy of the canvas too (paint_below_verify): 0 pixels differ. The copy is built 19 times whole and 206 times in part, where the old code built it whole 32 times; with the switch off (LORD_BELOW_SWITCH=0), 17 whole and 20 in part, and the same hashes. Breaking it on purpose fails the test (goldens and self-check): without the ancestor check, the transform check, the growth of a part, the paint order (the nodes before the window counted as after it) or the outside damage. Without the blur check nothing fails in these scenes (the blur would only read differently where the menu bar or the 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 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 paint_root stamps the ancestors of the node the frame starts from (skip_stamp, up to 64 levels; deeper, every node is walked as before), and a node before it that isn't one of them returns at once: no corner save or restore, no walk of its children. The ancestors keep theirs, since the window is clipped by them. Checked on VM 116 before the golden hashes were written again: every frame of test_drag_exact (1,816 on both paths) was compared pixel by pixel with the frame of the code before (whose hashes equal 001633b's): 178,634 pixels in 1,686 frames differ, all by exactly one level in one or more channels, 155,462 of them inside the corner squares of a rounded overflow: hidden node (n = ceil(r) + 1 px, the square canvas_corners_save keeps) and 23,172 inside the Dock's or the menu bar's backdrop blur, within the blur's reach of such a square. On the frames that are also compared with a full repaint, none of the 9,619 differing pixels moved away from it and 9,132 now equal it. The pixels that differ from a full repaint go down from 2,265 to 2,217 (CPU path) and from 70,940 to 70,882 (GPU path) in the long run. tests/drag_golden_cpu.txt and drag_golden_gpu.txt were then written again by make drag-golden, and the 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. Since the Pi 5 run of 2026-10-29 GPU drag is off by default and LORD_GPU_DRAG=1 turns it on (the first entry under Changed); the self-test runs only then. LORD_GPU_VERIFY=N paints W on the CPU too every N-th GPU drag frame and compares it with the framebuffer read back (gpu-verify: frame N W=wxh differ=K worst=D).
    • main.c keeps, per display, that the scene and the UI texture are stale in W (gdrag_on, gdragw): W joins the next frame's damage; a frame with no UI damage (the cursor, an app's new frame) draws the window again from the 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.
    • On the Raspberry Pi 5 with the final build (2026-10-29, with the uploads in slices): the self-test passes on V3D (gpu: GPU drag on: … self-test: 11373321 pixels, every valid premultiplied combination and a 4096x2048 placement pass, the same as the CPU's, 341 ms), and with LORD_GPU_VERIFY=1 the 138 GPU drag frames compared were all differ=0 worst=0. It no longer stalls: with the frame pipeline off, 59.9 fps alone and 30.8–31.6 fps under load (three runs) with GPU drag on, against 59.9 and 30.5–31.1 fps with it off (two runs). It composed only part of the frames (138 of 601 alone, refused: layer 214, after 241, catching up 8; 80 of 436 under load). Correct, but no measurable gain, so it is now off by default and LORD_GPU_DRAG=1 turns it on (the first entry under Changed).
  • GPU drag's textures catch up between frames instead of inside one (0.8.6, in development; docs/GPU.md, "Uploads without a stall"). A drag's start, or a copy of what is below built again whole, made the first GPU drag frame send the whole copy (a screen, 8.3 MB at 1920 × 1080) and the layer; on V3D glTexSubImage2D converts to the GPU's tiled layout 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; measured on the Pi 5 and off by default since then, LORD_PIPELINE=1 or 2 turns it on; docs/GPU.md, "The frame pipeline"; src/fpipe.c and main.c). A frame was started only after the previous flip completed, so input, JS, layout, paint, the upload, the GPU and the flip ran one after another; on the Pi 5 under an all-core load that chain (about 13 ms of CPU, 3–5 ms more) passes the 16.7 ms period, every frame waits for the second vblank and the monitor shows 30 frames a second, 98 % late.

    • 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: unset, 0 or anything else off (the previous behaviour exactly; the default since the Pi 5 run), 2 always, 1 on while frames are heavy: after 2 frames in a row whose CPU time passes 60 % of the period, off after 60 in a row under 40 % or at the first frame after more than half a second without one (FPIPE_IDLE_MS; an idle desktop gives no frames to count, and without this the pipeline stayed on through it, so the first input after it was shown a vblank later; that frame counts as the first of the two heavy ones that engage it again) (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. The theme's JS frame callbacks run once per frame shown: a prepare that painted nothing (FPIPE_EMPTY) had run them, and when they asked for another frame (an animation callback that changes nothing while an app's frames or the cursor keep the display flipping) the frame built after that flip ran them again, twice per frame shown; that frame now skips them and they run with the next one (fpipe_hold_callbacks, Out.prep_js). A prepared frame that is undone, or GPU drag's rectangle painted again on the CPU, joins the next frame's damage as a second frame's, so paint_out applies the blur rule again (paint_damage_settle). Checked on VM 116 after these two fixes (and the rebase onto the partial-repaint fixes): make -j8 with no warnings; fpipe-test 59 checks (new: the idle gap, at and past FPIPE_IDLE_MS, re-engaging after it, 2 and 0 ignoring it, a heavy drag then 2 s idle then a click; and a display flipping for an app on the GPU path while an animation callback changes nothing: 600 callbacks for 599 frames shown with the pipeline off, 1,200 with it before the fix, 601 after); engine-test 6,907 checks, 0 failures; lordbench-test 1,217 ok; make test 23 passed, 0 failed, 13 skipped. The pipeline itself still has not run on a display.
    • 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 had not run on a display then.
    • On the Raspberry Pi 5 with its monitor (2026-10-29, GPU drag on in both, two runs each): with the pipeline while frames are heavy, alone 60.0 fps (build p50 8.26–8.31, p99 11.90–11.98 ms, 0 % late), pointer to screen p50 42.1–42.5 ms; under load 33.0–36.2 fps (build p50 13.85–13.90, p99 19.07–19.36 ms, 65.8–81.6 % late), pointer to screen p50 77.3–79.8, p99 98.7–99.8 ms; every frame was prepared ahead, alone too (held for the flip p50/p99 8.40/15.72 ms alone, 18.27/31.60 under load). With LORD_PIPELINE=0: alone 59.9 fps, pointer to screen p50 25.5–25.7 ms; under load 30.8 fps (93.8–94.3 % late), pointer to screen p50 48.8–49.0, p99 66.1–66.3 ms. So it gave 2–5 frames a second under load for 17 ms more pointer latency alone and 29 ms more under load, and its auto mode engaged even alone at 60 fps (a frame of about 11.5 ms with the GPU's part passes 60 % of 16.7 ms): it is now off by default (the first entry under Changed).
  • js: unsupported style '<key>' is logged once per key (style_warn in ui/js.c), not on every setStyle call: a style an animation sends every frame wrote a line to the session log every frame (as transform did before LordBench's square and the fans moved to rotate). The first 64 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

  • System Information's Raspberry Pi power and throttling rows (2026-10-29; server/src/hw/rpifw.c, sysreport/sysreport.c, apps/sysinfo; tested on fake sysfs trees and VM 116; the shared reader ran on the Pi 5 in LordBench on 2026-10-29, the alarm present and reading 0, while System Information's rows were not looked at there): the collector looked only for the firmware's get_throttled (soc@107c000000:firmware on the Pi 5), which the rpi-6.18.y kernel LordOS ships doesn't have, so on a Pi 5 with LordOS the Power and Throttling rows were always empty (and the Markdown report said nothing). System Information now reads the firmware the same way LordBench's guards do, from one shared reader, hw/rpifw.c (rpifw_read, rpifw_parse_throttled; linked into lord-server, lordos-sysreport and both tests; bench/lbcond.c uses it instead of its own copy): the rpi_volt hwmon's in0_lcrit_alarm, exactly 0 or 1 (with an optional newline; anything else is unknown), and get_throttled where an older kernel has it (directly under a /sys/devices/platform node or its <node>:firmware child), strictly parsed (1-8 hex digits, optional 0x, one optional newline, masked to the eight known bits). World-readable sysfs only: no mailbox, no vcgencmd, no exec. What the kernel shows is reported and what it doesn't is left out:

    • The LordOS kernel (rpi_volt only): the Power row says "No under-voltage in the last few seconds" or "Under-voltage in the last few seconds: use the official power supply" (the hwmon asks the firmware every 2 s and clears the sticky bits, so it can't tell "since boot"); there is no Throttling row (the kernel doesn't expose the capped, throttled and soft-limit bits), never a false "never slowed down".
    • An older kernel with get_throttled and no rpi_volt: the rows as before, "now" and "since boot", and the soft temperature limit now counts as slowed down too.
    • Both: the sticky bits only cover the last 2 s window (rpi_volt clears them), so the rows say "in the last few seconds" instead of "since boot".
    • Neither, or a value that doesn't parse: model and revision only. The report's JSON raspberryPi gains underVoltageAlarm (true, false or null; throttled stays the raw bits or null); the Markdown report says "no under-voltage in the last 2 s (rpi_volt); throttling not reported by this kernel" on the LordOS kernel, and the now/since-boot/last-2-s wording with the raw bits on older ones. The rows' choice is piStatus in apps/sysinfo/model.js. Four new strings (en, es, pt). Tests: tests/sysreport_test.c (the Pi 5 fixture now has the LordOS kernel's rpi_volt and an empty soc@107c000000:firmware; thirteen small trees: that kernel with the alarm clear, set, yes, 01 and missing; an 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 transformed subtrees (paint_tf_nocache, tests only): test_damage_pipeline runs the reported scene (Monitor's moving map, a translucent, blurred Terminal minimized into the blurred Dock, the blurred menu bar, menus, the cursor) through a copy of main.c's whole bookkeeping (damage gathered while a page flip is pending, paint_out's parts, present_cpu's per-buffer lists and copy, the cursor) with 0, 30 and 60 % of the flips pending, and checks every presented buffer against the scene; test_damage_fuzz does the same with random trees and random changes (clipping, rounded, shadows, translucent, blurred, scaled, rotated, faded, zIndex, hidden, moved, resized, re-parented, destroyed). The double-buffer and cursor bookkeeping was right in every frame. The fuzz found seven bugs in the paint engine, all with one box per frame and with several rectangles, each able to leave a wrong area until something repainted it (before the fixes 11 of 12 seeds failed; now 1 of 48 in each mode, a single 1-pixel row of 17 pixels, plus a few levels on antialiased edges in a second rare case, both described in the test; the 12 seeds make test runs pass):

    • a node's border is drawn over its children; when a partial repaint started from an opaque child (the opaque-cover shortcut), the parent's border was skipped, so a child overflowing its parent lost the parent's border line where a small rectangle fell (paint_node);
    • a transformed subtree's cached raster stayed valid after a change made while the subtree was hidden or had scale 1, and came back with the old content (each node now has a generation counter, Node.gen, bumped by node_invalidate, in the subtree's signature, and the node's own style is compared every time);
    • a transform inside another transform: changes inside the inner subtree never reached the outer raster's signature, so the outer raster stayed cached with old content;
    • the raster's pixel grid moved with the subtree's extent, so a child moving inside an unclipped scaled subtree resampled every edge of it outside the damage (the grid is now fixed to the node);
    • when a blur, a terminal or an app window came into or left a transformed subtree, its raster changed resolution or kind and every pixel of it changed, but only the node that came or went was damaged (the whole subtree is now);
    • a blurred surface repainted with only its own box read, outside the repainted area, the last frame's final pixels, including whatever is painted above it (a sibling's shadow, a menu, a window's border), while a full repaint blurs only what lies below: its edges kept the difference. The margin its blur samples (twice the radius) is now repainted with it (blur_near, in blur_walk and the several-rectangles rule); in test_multi_damage this raises the pixels repainted per frame from 24,078 to 27,363;
    • a display whose flip was pending gathers several frames' rectangles and dlist_add joins the ones that overlap; a join, or an older frame's rectangle after a blurred node moved, could cut through a blurred node, whose blur then depended on where the cut fell. paint_out now applies the blur rule again to damage gathered over more than one frame, on the tree as it is painted (paint_damage_settle). Which of these was the 0.8.2 report is not proven (the reported scene itself never failed), so several rectangles stay off by default (LORD_DAMAGE=multi). Built with make -j8 (no warnings), make test and build/engine-test on VM 116. Checked on a running desktop (VM 116, 2026-10-29; docs/MONITOR.md, "0.8.6: the search for the grey rectangle"): an isolated headless session of the real default theme at 1280×800 (CPU composition), driven over its remote desktop socket by a viewer that keeps its own copy of the screen from the tiles the session sends every frame, so the copy holds exactly what the partial repaints left. The 0.8.2 scene: Monitor → Network with ten slow downloads to mirrors in ten countries (the map's dots moving), a Terminal at 30 % transparency with blur over the map, minimized into the Dock and restored 22 times, the Terminal's six menus opened and closed, 54 checks per run. At each check a second connection makes the session repaint the whole screen and the two are compared (pixels that changed within 2.2 s before or after are left out as animation; the downloads are paused for the check so the dots are still). Six runs: this commit and the previous main, each with one box (the default) and with LORD_DAMAGE=multi, and both builds again in the default mode with the scene still for 7 s before each check. No stale area in any run, before or after: with the scene still, 0 differing pixels in 54 checks (this commit) and 3 single pixels on the Dock's corner (the previous build); with the scene moving, only Monitor's live numbers and charts that changed between the last partial frame and the full one, a few antialiased pixels of the Dock's corner, whose blur takes in Monitor's live "Load" line (both builds, 1 to 7 pixels), and, in 5 of 108 checks of this commit, a map arc that faded under the blurred Terminal in that gap (at most 3 levels of 255; gone with the scene still). The 0.8.2 grey rectangle did not appear in either build, so it is still not reproduced. Cost (the same sessions, one remote viewer, lord-server whole process, % of one core, 5 × 30 s, two batches): Monitor → Network 56.7 / 57.2 % before, 58.7 / 59.7 % after (one box) and 59.2 / 58.1 → 57.2 / 58.0 % (several rectangles); with the blurred Terminal over the map 35.8 / 36.4 → 38.0 / 37.7 % and 36.7 / 36.6 → 37.5 / 35.9 %; layout and paint per frame (LORD_FRAME_STATS) the same within 0.1 ms in every case (14.6 to 14.8 ms). In these sessions (--profile) every frame repainted one box of 64 to 79 % of the screen, also with LORD_DAMAGE=multi (the moving dots, Monitor's live numbers and charts on both sides and its footer next to the blurred Dock never stayed several rectangles), so the blur margin adds next to nothing there; the per-frame difference measured in test_multi_damage (24,078 → 27,363 px) was not visible at the process level. Why the 0.8.2 VM 119 scene gave 5 to 11 rectangles and this one gave one: a translucent, blurred Terminal hidden behind Monitor (next entry). 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.
  • A blurred window hidden behind another no longer makes every frame repaint it (paint.c, blur_hidden; both damage modes). The blur rule (a change that touches a blurred surface or the margin its blur samples repaints the whole surface and its margin) also held for a blurred surface covered whole by an opaque window above it, which shows nothing of its blur. A translucent Terminal (30 % transparency, blur) behind Monitor → Network: every frame of the moving dots repainted the hidden Terminal's body and margin, one box of 45 % of a 1280×800 screen (62 to 73 % when its margin met the Dock's, which then joined), even with LORD_DAMAGE=multi, where without it the dots are a few rectangles under 1 % of the screen. Now a blurred node that an opaque node painted after it covers whole (the same test as the opaque-cover skip: opaque background, opacity 1 down the tree, no transform, away from rounded corners, clipped by its ancestors; CPU path without a dragged window) is left out of the rule; when the window on top moves, turns translucent or closes, the change reaches the blurred one and the rule applies again. A blurred Terminal in front of the map is still repainted whole with its margin every frame (75 to 80 % of the screen when its margin meets the Dock's): that is the rule itself. Found on VM 116: the sessions of the repaint check above (and their --profile numbers) had such a Terminal behind Monitor, restored from a lord-term-holder left by an earlier run (the harness killed holders with a pattern that never matched the holder's process name). Measured (VM 116, isolated headless session, 1280×800, CPU composition, one remote viewer, --profile, last 150 frames): repainted per frame 46.4 → 14.5 % (one box) and 46.2 → 3.8 % in 5.6 rectangles (several), paint 5.6 → 2.0 ms and 5.2 → 1.7 ms per frame; lord-server (whole process, % of one core, 5 × 30 s, two batches): 24.3 / 22.3 → 13.2 / 15.3 % (one box) and 21.5 / 21.7 → 15.0 / 14.3 % (several). With no hidden blurred window the frames are the same as before (Monitor → Network alone, one box: 10.2 / 13.8 % per frame, the live charts). Checked: test_hidden_blur_damage in build/engine-test (a blurred window under an opaque one with moving dots, both modes: every frame matches a full repaint while the hidden window moves and the one on top moves away and back, turns translucent, closes and reopens; the hidden window no longer joins the damage; a visible one is still repainted whole; three of its checks fail without the change); make test and a full build without warnings on VM 116; and on a running desktop with the repaint check above, the original scenario (54 checks per mode) and a new one with the Terminal hidden behind Monitor's moving map, raised over it and sent back ten times (21 checks per mode): no stale area in either mode, only Monitor's live numbers and charts and the clocks changing between the two copies. Rebased onto the frame-cost work and checked again (2026-10-29, VM 116): blur_hidden stays off with a dragged window, on the GPU path (so with GPU drag) and inside a transform; the damage of a frame the pipeline undoes, or of GPU drag's rectangle repainted on the CPU, goes through paint_damage_settle, which applies the same rule to the tree being painted. A build without warnings; make test (23 suites passed, 13 skipped for missing tools); engine-test 7,010 checks, its drag runs printing exactly what main's build prints (the golden hashes of 2,417 drag frames per path unchanged); fpipe-test 61 checks; lordbench-test 1,217. The first check of the 0.8.2 scenario above never minimized the Terminal: with the leftover holder gone a fresh Terminal opens at another place, and the scenario's click, placed for the restored one, missed its minimize button. The click now hits it, and the rebased build was checked with the Terminal minimized into the Dock and restored 22 times: 0 differing pixels outside Monitor's live numbers and charts and the clocks in all 54 checks, one box and several rectangles, with the downloads paused 2.5 s and with the scene still 7 s before each check (four runs); the hidden-Terminal scenario, 1 pixel (a Dock corner next to Monitor's live Load line) and 0. The live areas left out now also hold the fresh Terminal's footer clock, Monitor's left-panel chart and the curl row's sparkline, which the restored Terminal used to cover. --profile on the rebased build, the Terminal hidden behind Monitor → Network: 11.2 % of the screen per frame in one box (paint 1.24 ms) and 3.3 % in 5.8 rectangles (0.82 ms); Monitor alone: 9.1 % and 3.2 %.

  • 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 the compositor's main thread waited 299 ms per second for a CPU under load (17 ms alone). Now lord-sessiond gives the session's server leaf cpu.weight 1000 (apps and helpers keep 100), in the root-owned subtree it already manages (CG_SERVER_CPU_WEIGHT, sec/cgroup.c). LordBench's desktop test under load on the Pi 5 without its monitor, two runs each: 43–45 → 56–57 frames per second, late frames 31–33 % → 7–8 %, pointer to screen 32–33 → 22 ms median and 67–75 → 52–53 ms for the slowest 1 %; nothing changes without load. Checked on VM 116 that a new session gets the weight. On the Pi's monitor with GPU composition the weight was measured only together with the real-time priority (next entry). A 0.5 ms scheduler time slice for the compositor's threads was also tried (it was in the previous commit) and removed: measured alone, it made no difference; its first numbers had been inflated because the test tool also gave the slice to the load. What remains is described there.

  • The desktop under load, second step: a real-time priority for the compositor (approved by the maintainer on 2026-10-28; docs/BENCHMARK.md, "The desktop under load"). With the weight, the compositor's main thread still waited up to a scheduler tick each time it woke up under load. Now lord-sessiond starts the session's lord-server with RLIMIT_RTPRIO 2 and RLIMIT_RTTIME 5 s (remote/sess.c); lord-server, right after dropping root and before it starts any process or thread (par_init, par.c, moved there in main.c), puts its main thread and its paint threads at SCHED_RR priority 2, gives the main thread SCHED_RESET_ON_FORK so everything it starts later gets the normal policy, and lowers RLIMIT_RTPRIO to 0, soft and hard, so no app, helper or shell can ask for real time. The root admin helper lowers its own limit to 0 as well (its download child drops to nobody). A thread that runs 5 s on real time without blocking gets SIGXCPU and every thread goes back to the normal policy; nothing is killed. The session log says compositor at real-time priority 2 (SCHED_RR, N threads). Checked on VM 116 with the new lord-sessiond (main thread SCHED_RR|SCHED_RESET_ON_FORK, 7 paint threads SCHED_RR, every other thread and child SCHED_OTHER with a limit of 0). LordBench's desktop test under load on VM 116, two runs each: late frames 2.65–2.92 % → 0.28 %, frame build p99 16.3–16.8 → 11.0–12.7 ms, pointer to screen p99 31.0–32.3 → 24.7–25.5 ms (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; 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 through the render node fd lord-server opens), and the Pi reports a hardware GPU.

  • Raspberry Pi image on an x86-64 host with an aarch64 server/build: tools/iso/mkdeb.sh checks the signed system code by running lord-server --check-code, which can't run an aarch64 binary on x86-64 (it failed as "the staged system code does not match code-manifest.json"). CODE_CHECK_SERVER now names a lord-server built for the host from the same tree, and tools/rpi/build-img.sh asks for it instead of failing later. Found building the 0.8.5 image; the check itself is unchanged (docs/SIGNING.md).

  • Same build, unstripped binaries: mkdeb.sh stripped with the host's strip, which can't read aarch64 binaries and whose errors are ignored, so that package shipped every binary with its symbols (17 MB instead of 11 MB, the same files). It now uses aarch64-linux-gnu-strip when it packages arm64 on another architecture, and stops if it is missing.

  • Public docs corrected ahead of 0.8.6 (a read-only audit, each finding checked against the code and the measurements):

    • Paper (en, es, pt; docs/PAPER.md regenerated): §7.2 no longer says a dragged window's rounded corners stopped turning black on the monitor; it says what the 0.8.5 fix did (on the GPU path only pixels inside an app surface are taken for a Linux window's hole) and that small black squares can still show at the corners, on the CPU and GPU paths. §10.2 lists them as a known limitation (fixed in development on the perf-frame branch, not released), and the remote-desktop line no longer says the monitor shows them right. §7.4: the board results are "without a monitor unless stated", and the CPU weight alone is said to have been measured on the monitor only together with the real-time priority (it said the monitor measurement was pending, then gave it). The PDF/Markdown header writes the organisation as iPERFEX, as in meta.json (web/lib/papermd.mjs no longer upper-cases it).
    • FAQ (en, es, pt): "about thirty native apps" instead of "more than 35" (the paper says thirty-one); memory given as the paper measured it (lord-server about 50 MB in a user session) instead of an unsourced "120 MB idle session"; the Raspberry Pi 5 answers say the image shows the desktop on an HDMI monitor since 0.8.4.1 and that two monitors and 4K are what is untested; "KDBX files" instead of a brand name; the LordBench answer says the desktop under load is being fixed (as without load on VM 116; 24 → 29–30 fps on the Pi 5 with its monitor, the rest still in progress) instead of "already fixed", and a doubled word in Spanish is gone.
    • Features (en, es, pt): Linux apps no longer says a Flathub section is planned for 0.8.6 (Flatpak is not planned for any release; docs/FLATPAK.md); A desktop of its own says the Pi 5 has been tested with one HDMI monitor (not with two or 4K) instead of never with a monitor; Private by design adds lord-fetch, lord-tls and lord-bench (in development) to the sandboxed helpers; the Portuguese page puts its screenshot where the other two do.
    • docs/BENCHMARK.md: the status lists what is built (interface and video workloads, desktop-impact mode, boot test, lordos-sysreport bench, two of three references) and what is not (the x86 PC reference, a checks subcommand); the CLI diagram shows report | fetch | bench; the design table notes xz instead of deflate and software-only video decoding; the Pi 5 reference is the 16 GB board; the desktop test's turning element stays still in this build (there is no transform style key; fixed in development with a rotate key); the Quick-run times (33 s, then 39 s and 46 s from a terminal) are told apart; "not yet measured with the monitor" and "about 20 % slower" are replaced by what was measured (a frame takes 15–16 ms instead of 7 ms under load, cause not measured).
    • docs/ROADMAP.md: the black-corners item under Release 0.8.6 is unticked (fixed on perf-frame, not merged); "Pending before the final ISO" is marked done; LordBench's "Left:" adds detecting the Pi 5 firmware's throttling; the Pi 5 report item says what is still missing. docs/FLATPAK.md points to the roadmap item's current title.
    • docs/PAPER-VALIDATION.md: the Pi 5 load result is recorded as measured on the monitor with both changes; one Full and four Quick runs; 34 folders in apps/.
    • README.md: the "Measured, not promised" numbers are labelled as the pre-release 0.7.0 ISO test and joined by the released 0.8.5-beta's (592 MB whole system, first frame 7.4 s after the kernel); the repository map adds lord-bench (in development).

0.8.5-beta - 2026-10-27

Added

  • A curated catalog of AI apps in the LordOS repository. apt/catalog.json lists nine apps with their package, summary (en/es/pt), licence, vendor, architectures (amd64 and arm64) and a pinned source; apt/keys/ holds the vendors' APT keys, apt/recipes/ LordOS's build recipes and apt/build.sh checks and fetches them (apt/README.md, docs/UPDATES.md "Mirrored apps (catalog)"). Claude Code, Claude Desktop, Visual Studio Code and Cursor come straight from their vendors' signed APT repositories ("direct"): apt/build.sh check verifies the pinned key fingerprint, the signed InRelease, the index hash and the package for each architecture. The other five are verified on the maintainer's machine and published in pool/catalog/ by tools/release/apt-repo.sh build … --catalog: goose 1.56.0 and opencode 1.19.4 (the vendor's .deb, pinned SHA-256), and three packages LordOS builds in debian:trixie containers with no network — llama.cpp 0.7.0, the local model runner (-hf downloads GGUF models from Hugging Face over HTTPS; every CPU variant built and the best one picked at run time, plus the Vulkan backend, loaded only when a Vulkan device exists), whisper.cpp 1.9.5 (CPU) and codex-cli 0.164.0 (OpenAI's static binary, its sigstore signature checked with cosign). Vendor packages are never modified; what their maintainer scripts do when the Store installs them (VS Code, Claude Desktop and Cursor add their own APT source) is documented.
  • Store → Artificial Intelligence. The catalog as a page of the Store: each app with its kind, vendor and licence, dimmed on an architecture it doesn't support. An app from its vendor's repository first says whose repository it adds and its key fingerprint, then adds it (pkg-source-add, the key checked against the catalog's fingerprint) and fetches the lists; removing the app removes that repository unless another installed catalog app uses it. An app LordOS builds that the lists don't have yet offers to fetch them again instead of "package not found". Cursor's package always writes its own source (cursor.sources, Signed-By: /usr/share/keyrings/anysphere.gpg), and a second entry for the same repository with another Signed-By stops apt reading any source, so its catalog entry names those files and LordOS writes the same ones (the key dearmored). Tested on the VMware machine: llama.cpp installed from the Store (14 MB), llama-server -hf ggml-org/Qwen3-0.6B-GGUF:Q8_0 downloaded the model on first run and answered over its HTTP API on the CPU (about 33 tokens/s, no Vulkan device); on VM 116, Cursor's and VS Code's sources added, Cursor installed (its own script rewrote the same file), apt update and the Store's own update both clean, then removed.
  • The Store's new look. A sidebar in three groups (Store: Discover, For this computer, Installed, Updates; Categories: Artificial Intelligence and Debian's ten categories, each with its count; LordOS apps), the page's title, a back button and the search in a toolbar, and apps as cards in a grid that fills the window: icon, name, category, two lines of summary, the download size and a Get, Open or View button. Discover opens with a featured banner, then the AI shelf and a shelf per category with "See all"; an app's page has a larger icon and a row of facts (version, size, category, distribution). The hardware suggestions moved to their own page, For this computer, which keeps the badge for new ones.
  • A featured banner LordOS can change without a release. Discover's banner comes from apt/featured/featured.json and apt/featured/banner.png in the repository: apt-repo.sh checks them (a schema 1 JSON object of at most 64 KB, a PNG of at most 2 MB) and publishes them signed with the indexes (main/featured/), and the package engine takes them only from a source whose signed Release says Origin: LordOS, checks their hashes, parses the JSON and the PNG signature, and keeps them in /var/lib/lordos/pkg/ (lord.pkg.featured(), read-only). The picture fills the banner under a shade; while it isn't there yet the Store draws a skeleton of the banner (it pulses, unless Reduce motion is on), and a system whose repository has no banner shows a catalog app instead. Tested on VM 116 against lordos.org/apt-staging: the banner, its skeleton without the image, For this computer, the categories and the cards.
  • Store → Commercial. Free-of-charge apps whose source code isn't public, from their makers' signed APT repositories with the key LordOS pins: Google Chrome (amd64 and arm64), Edge and Spotify (amd64). The page says before anything is installed that LordOS can't review or fix what they do, and points to For this computer for graphics drivers. Their packages write their own APT source: for Chrome and Edge the catalog names those files (google-chrome.sources, microsoft-edge.sources and their keyrings) so the package's write changes nothing, and for Spotify, which adds spotify.list unless that file exists, a new catalog field optout makes pkg-source-add create it empty (only when missing; pkg-source-remove deletes it only while it is still empty). Tested on the VMware machine with the admin action and LordOS's package engine: the three sources added, the three apps installed (Chrome 156.0.8078.47, Edge 156.0.4314.50, Spotify 1.2.95), apt update with no error or warning and the engine's update clean afterwards, and Chrome's window opening in the session. Spotify's package also copies its key into /etc/apt/trusted.gpg.d/, trusted by apt for any source without Signed-By (Debian's own sources have one). Steam needs i386 multiarch, which LordOS's package engine doesn't do yet (roadmap).
  • Root over SSH, as an advanced option. Settings → Sharing → Advanced lets an administrator allow root to log in over SSH with a public key only, or with a key or a password, for tests and administration: the keys are pasted or imported from a .pub file and listed with their fingerprints, root's password can be set, every change asks for your password again, and a warning stays visible while it is on. Off by default, and off again with one click.
  • The Store downloads over HTTPS. LordOS's package engine now speaks HTTPS as well as HTTP: a small sandboxed helper (lord-tls) checks the server's certificate and name and encrypts the download, so repositories that only accept HTTPS work, and what you install is private on the network. Every package is still checked against its signed index, as before; a secure download is never redirected to plain HTTP.
  • A guide to building an appearance. docs/THEMES-GUIDE.md explains, for a React developer new to LordOS, what a theme is, its parts (theme.json, tokens, the shell, window frames, menus, layers), right-to-left, light and dark, several displays and the performance rules, how to build and test one, and a checklist; examples/theme-minimal/ is a small working theme to start from. It also says plainly what is missing: a theme LordOS didn't sign doesn't load on a release build yet (no theme package format or user trust decision exists).
  • Settings → Displays: numbers, Identify and snapping. With more than one display each one has a number (the main display is 1); clicking a display in the arrangement, or Identify, shows its number big on that monitor for a moment, so you know which screen is which. Dragging a display snaps it edge to edge and aligns it with the others (side by side, stacked or offset), and a drop never leaves two displays overlapping or apart. The server keeps a position that fits exactly, and a chain of three displays is no longer pulled back onto the main one on every change.
  • A fuller Window menu, in both themes. Minimize, Zoom, Fill, Center; Move & Resize with the left, right, top and bottom halves, the quarters and thirds, arrangements of two windows (left and right, right and left, top and bottom, bottom and top) or four (quarters) with the windows behind it, and Return to Previous Size; Move to for every other display (a snapped window keeps its zone, the rest keep their place relative to the screen); Bring All to Front; and the open windows, the one in front checked.
  • Dock: Open at Login and Assign To. A Dock item's Options menu can open the app when you sign in (started the same way as a Dock click) and, with more than one display, assign it to a display: its new windows open there (kept by the display's name across boots).
  • One place to choose the desktop style. Settings → Appearance → Desktop style now lists every installed theme, and the separate Themes page is gone (an old link to it opens Appearance).
  • The app menu and Force Quit (Lord Flow). Clicking the app's name in the menu bar opens its menu: About (its icon, name, own version and where it comes from), Settings… (the app's own, ❖,), Hide , Hide Others, Show All and Quit (❖Q). The crown menu adds the Store, with how many updates are waiting, Recent Items, and Force Quit…, which lists the open apps and ends the chosen one without asking it: a Linux or isolated app's own process only (lord.wayland.kill, the same user's client, never X11, which is asked to close), a built-in app without its close guard. In Lord Classic, About is in each window's Help menu.
  • The themes are called Lord Flow and Lord Classic. The menu bar and Dock theme (formerly Lord Default) is now Lord Flow, and the taskbar and start menu theme (formerly Classic) is Lord Classic, in every language. Only the names changed: your choice is kept.
  • Menus inside the window in Lord Classic. Lord Classic has no menu bar on top, so an app with menus of its own (Files, Text Editor, Notes, Terminal, PDF Viewer, Photos, Screenshots, Mail, Passwords) shows them in a strip under its title bar (File, Edit, View, Go…, then Window and Help), as desktop apps do with a taskbar; apps without menus of their own get no strip.
  • Every native app has its own version. Each app's manifest now carries a version (all start at 0.8.5), the build refuses an app without a valid one, and Store → Installed shows it next to the app ("LordOS app · 0.8.5"), so the apps can later be versioned and released apart from LordOS.
  • Boot time, on the screen and on record. The boot splash shows the time since it started, in seconds and milliseconds, in the bottom right corner. About LordOS → Startup time shows how long this boot took from the kernel's start to the login screen (or, with automatic login, the desktop). Every boot is logged with the LordOS version and build (journalctl -b -u lordos | grep "first frame") and kept in /var/lib/lordos/boot-times.jsonl (the last 200 boots), so boots and versions can be compared; docs/RESULTS.md explains how to check and compare them.
  • lordos-fetch. Type it in a terminal to see the LordOS crown beside a summary of your computer: system, kernel, CPU, GPU, display, memory, disk, packages and how apps are isolated. lordos-fetch --share leaves out your user and computer names, for a screenshot you'll post.
  • System Information (About LordOS → System Report…): every piece of hardware this computer has and what LordOS makes of it. The graphics card is shown layer by layer (driver, display output, render node, GPU context, composition, direct scanout) with the exact reason when the screen is composed on the CPU, and a Compatibility panel says what works, what works with limits and what wasn't checked. Its Report tab shows the exact text of a report (Markdown or JSON) before you copy it or save it to Documents; nothing is sent anywhere. Its Checks tab checks LordOS's claims on this computer (display server without root, Landlock, the per-app firewall, verified code, the remote desktop closed when off, app scopes owned by the system) and says whether each was only found configured or actually tried. Run tests starts a test app that tries, inside the same sandbox as any isolated app, what it must not be able to do (your files, sockets, ptrace, leaving its scope, exec), plus the decoders' sandbox and the requests the system must refuse.
  • Linux video players can keep the screen on (idle-inhibit), and an app that copies now sees its own copy in the clipboard as the Wayland protocol says.
  • Test Bench (lordos-testbench): a test pattern window that checks the display server from the outside: frame timing and when frames really reach the screen, every key of the keyboard, the mouse and wheel, and the Wayland protocols the system offers. G draws a 3D scene and says whether a real graphics card or the processor renders it; V plays generated video at 24, 30 or 60 frames a second; L locks the pointer; its last report appears in System Information → Checks. Its frame times give the average, the 99th percentile and the frames that missed the display's refresh budget. Keys LordOS keeps for itself (Print Screen, the media keys, ❖ on its own) are outlined in purple.
  • Versioned results. tools/results/collect.sh writes the evidence for one machine into results/<version>/<machine>/: the hardware report, the Test Bench's report, whole-system memory with PSS per process, and the boot time, with the conditions and the exact commands (docs/RESULTS.md). Releases attach them to the GitHub release.
  • Monitor → Network shows ping (ICMP), raw IP and packet sockets (the last two can see or forge traffic: the row says so, with the protocol or ethertype and the interface), under the app that opened them, and the remote desktop's own UDP ports under Remote Desktop instead of an unknown "?".
  • lordos-sysreport report prints the hardware of this computer and what the system made of it, as Markdown or --json, with no serial numbers, addresses or names: the base of System Information.
  • Files: This Computer and every disk. The sidebar now has This Computer, to browse the whole system read-only as your user (the system's own permissions decide; the kernel's /proc, /sys, /dev and /run stay out), and every disk with a file system: one that isn't mounted shows dimmed and a click mounts and opens it (an internal disk asks for an administrator, as in Disks); a removable one can be ejected from its ⏏. Folders you can't write show no actions that would change them.
  • Monitor → Network, second generation. The app list is now a tree: each app opens into the sites and addresses it talks to, and each address into its ports, with what was sent and received everywhere, a small live meter and an allow/block switch on every destination. One pop-up button holds the whole view (group by app, domain, address, port or country; incoming or outgoing; TCP or UDP; allowed, denied or with rules; sort by name, most or least traffic, most recent or most connections), remembered for each user. The search turns app:, domain:, ip:, port:, proto: and country: into chips you can combine, and the history zoom (1 h to 30 d) now also shows each app's traffic for that window.
  • LordOS's own parts have their own rows and rules. Mail and the calendar sync, the Store and updates, printers and scanners, the Terminal (with the names of the programs you run in it) and the blocklist updates each run in a process of their own, so you can see and block each one separately, and the kernel enforces it. Blocking the Store asks first, because security updates stop. Name resolution, time synchronization, the network service and your VPN tunnels are shown too, and are never blocked.
  • Blocklists. Settings → Privacy → Blocklists offers public lists of advertising, tracker, malware and attacking sites, each with its source and licence; turn one on and LordOS downloads it over HTTPS once a day, in a sandboxed downloader, and blocks those destinations for every app. You can add your own list by its https address. A rule you write for a site always wins over a list: switch a blocked site on in the Monitor and it stays allowed.
  • Deny silently. A new firewall mode: only what a rule allows can connect, and everything else is denied and recorded (this computer's own services keep working). In Settings → Privacy and in the new menu bar item.
  • Network activity in the menu bar (optional, off by default): upload and download rates in the menu bar, and a panel with the last five minutes, the apps moving data now, what was recently denied, the firewall mode, the blocklists and a link to the Monitor.

Fixed

  • A session started at boot could live without its keyring service and its notifications. With automatic login, lord-sessiond started the session as soon as /run/user/<uid> existed, a few milliseconds before the user's service manager opened the session bus, so lord-vault (the Secret Service) and the notification server for Linux apps never got on the bus. Apps then got nothing, or, when an app had pulled in gnome-keyring, that one by D-Bus activation, with its own "Choose password for new keyring" window. lord-sessiond now starts user@<uid> and waits for the bus socket (up to 5 s) before starting the session. And when an app pulls in gnome-keyring, a drop-in shipped by the lordos package (gnome-keyring-daemon.service.d/lordos.conf) keeps only its PKCS#11 component, so LordOS's own keyring keeps the Secret Service. Tested on the VMware machine: after a reboot with automatic login, org.freedesktop.secrets and org.freedesktop.Notifications belong to the LordOS session, and Chrome asks through LordOS's own keyring prompt.
  • The Store ignored a repository written as Architectures: amd64,arm64. apt accepts commas there (Cursor's package writes it that way); LordOS's package engine split only on spaces, so it dropped that source and never saw the app's updates. Both are accepted now.
  • Locking the screen and switching user are faster. Handing the screen to the sign-in screen waited for every input device to close, and the last close of a USB mouse stops its transfers: about 0.7 s for VMware's virtual USB mouse, so a lock took 0.6 to 1.1 s there. Access is still cut at once (EVIOCREVOKE); the close now happens on a short-lived thread. Measured on a VMware Fusion VM: 903 ms → 141 ms from the lock to the sign-in screen. A slow hand-off is logged with the time of each step.
  • A dragged window's corners on the GPU path. While a window is dragged it is painted from a cached layer, and on the GPU path every fully transparent pixel of that layer was taken for the hole of a Linux app's window, including the pixels outside its rounded corners. Now only pixels inside an app surface can be holes. (Black corners while dragging were also seen in remote-desktop frames; that path is still being looked at.)
  • Dock → Options → Assign To with two monitors of the same model. The assignment was kept by the display's name, which two identical monitors share: both showed as checked and new windows went to the first. It is now kept by the connector (HDMI-A-1, DP-2…); an assignment saved by name still works while that name belongs to one display. Verified on VM 118 with two displays of the same name: Notes assigned to the second display opens there after being moved to the first and quit.
  • The sign-in and lock screen with several displays. It was laid out over the whole desktop, so the clock, the user and the password field were cut at the seam between two displays; they now go on the main display (the wallpaper still covers every display) and follow a display plugged in or out while it shows. Verified on VM 118 with two displays.
  • Monitor → Network: the map always shows the traffic. The arc to a country with no traffic at that moment was drawn almost transparent, so a selected app's destinations looked unconnected; arcs now stay plainly visible. Any traffic moves dots along the arcs (orange out, green in), not only above 256 B/s, so a slow app (a ping, a chat) shows its direction too. And the map follows the search and the filters like the list does: all apps, the selected app, or only the connections the filters leave. Short connections (a page, a download) used to close before their own rate was read, which left the arcs still while the app moved megabytes: the app's own rate is now spread over its destinations.
  • Monitor → Network: one color per app on the map. Each app's arcs have their own color, shown as a dot before the app in the list, and apps that reach the same country get separate arcs, so Chromium, the Terminal and the Store can be told apart; the moving dots stay orange (out) and green (in).
  • Monitor → Network: ping counts under the Terminal. Ping and raw sockets carry no cgroup of their own, so ping run in the Terminal showed as a separate, empty app; such sockets now take their process's cgroup and appear under the app that ran them.
  • Monitor → Network: a click on the empty space under the list clears the selection.
  • Two failed theme switches in a row could leave the session without a theme. After a theme was refused, the server still took it as the current one, so a second refused switch fell back to it. Now the last theme that loaded stays the fallback.
  • Apps whose launcher file has a space in its name didn't appear in Apps. A package may name its .desktop file freely (the LordOS Imager's is LordOS Imager.desktop), but the launcher skipped any name with a space or another unusual character. Such a name now gets an id with those characters turned into -, and the app is listed and launched from its real file. Also, an app installed in the same second the list was last read now shows up (the folders' times are compared in nanoseconds).
  • A see-through line around the Terminal. The Terminal's window has a transparent background, so its 1-pixel border and the line under its title bar let what was behind the window show through (a colored line when it was over another window). Both are now drawn opaque for transparent apps, in Lord Flow and Lord Classic.
  • The login screen no longer stays running behind your session. It was a whole display server kept in memory after sign-in (about 53 MB of its own, 78 MB counting shared pages, measured in a VMware VM). It now closes 10 seconds after a session takes the screen and starts again in a few milliseconds when you lock, switch user or log out; the whole system went from 603 to 548 MB in use. When you lock, the screen goes dark first and only then is the login screen started, so the unlocked desktop is never left visible meanwhile. Also fixed: asking for the login screen twice on a lock (the monitor handed over a second time), and its mode coming out empty when a request was retried.
  • On virtual cards that don't wait for the screen's refresh, the desktop drew hundreds of frames a second. The VMware graphics driver (vmwgfx) completes each page flip at once, so the compositor and every app followed it at 500–580 frames a second on a 60 Hz display, using CPU for frames nobody sees. LordOS now notices flips that complete within an eighth of a refresh, again and again, and paces frames to the display's refresh on a fixed grid (59.8 frames a second at 60 Hz measured, p99 18.4 ms); real graphics cards are unaffected. The same grid also paces sessions without a monitor, so waiting in whole milliseconds no longer turns 60 frames a second into 57.
  • The package now depends on libwayland-egl1 when the Test Bench is built with its 3D view, so lordos-testbench starts on a system that didn't have it.
  • Remote desktop video came in blocks for the first minutes, and had no sound. The browser's bandwidth estimate was a fixed ceiling, so a new connection stayed near 3 Mbit/s for about three minutes; it now reaches the top in about 10 s on a local network and still slows down on congestion. Software H.264 keeps its deblocking filter. Drawing without a GPU (a remote-only session, a virtual machine) is faster with the same pixels: the backdrop blur 2.5×, rounded rectangles 2×, and canvas.c builds at -O3. The video now follows the browser screen's refresh rate (60, 120, 144 Hz…) instead of a fixed 30: a video window under blurred windows went from 18 to 35 frames a second on a virtual machine without a GPU. Heavy frames paint on several threads (up to 8, only while needed): a 1080p session went from 45 to 55–58 frames a second.
  • The keyring box couldn't be answered when several apps asked at once: every new request wiped the field and Cancel brought it back for the next one. One answer now goes to all of them, and a key listener that fails no longer keeps the key from the others. The page starts muted, as browsers require, and its sound button hides in the top bar: the first click or key in the session now turns the sound on.
  • Files → This computer shows /proc, /sys, /dev and /run with a lock and says why it doesn't open them, instead of "outside your home folder".
  • Restart… and Shut Down… in a session seen only through the remote desktop showed the countdown and then did nothing: only the session on the monitor can ask for them. They are now offered only there.
  • The Store now follows apt's priorities (/etc/apt/preferences.d), choosing the same versions as apt. On the Raspberry Pi image, "Update all" could take Raspberry Pi's builds of Chromium, BlueZ and other Debian packages instead of Debian's; it no longer does, and Raspberry Pi's kernel packages stay blocked as the image intends.
  • LordOS Imager offered 0.8.3 as the newest Raspberry Pi image. It only accepted release tags with three numbers, so it skipped 0.8.4.1; point releases (v0.8.4.1-beta) are now listed and downloaded, in LordOS and in the desktop app, and the desktop app's update check reads them too.
  • A monitor plugged in after boot now shows the login screen. The login screen never listened for the kernel's display events, so a board booted without HDMI (a Raspberry Pi 5) stayed without video until it was restarted. It now follows them like a session does, without the system bus.
  • The Store's package engine could not download packages with a + in their name (kms++-utils, libkms++0) from lordos.org: the CDN reads a bare + as a space and answered 404. It now sends %2B, as apt does, so Settings → Board firmware can install the bootloader tools from the LordOS repository alone.

Known issues and limitations

  • Remote desktop: black corners on a window being dragged. While a window is dragged, the frames the remote desktop sends can show its rounded corners black; the monitor itself shows them right (checked on VM 116 against the display output). Being looked at.
  • llama.cpp on a GPU is not tested on real hardware yet. Its Vulkan backend is meant for AMD (Mesa RADV), NVIDIA (the NVIDIA driver or NVK) and Intel GPUs and falls back to the CPU without one; only the CPU path and the backend loading (software Vulkan) were checked.
  • Legacy BIOS: a black rectangle between the boot menu and the splash. The menu itself shows normally; when its 5 s run out (or Enter is pressed), GRUB loads the kernel and the initrd (about 100 MB) from the disc and shows its terminal area, painted black, inside the theme's background until the kernel starts: a few seconds on BIOS, which reads the disc slowly, and barely visible on UEFI. Seen on QEMU with SeaBIOS; 0.8.4's ISO does the same. Small test images with the same GRUB, theme and grub.cfg but no 900 MB system image show the menu and no rectangle; a background image set in each entry and a hidden countdown widget in the theme did not change it.
  • Searching "displays" in the search panel opens the Help article on touchpads and touch screens before Settings → Displays.
  • Settings → Displays: in the arrangement, the name of a small display is cut without an ellipsis.

Upgrading

  • From 0.8.4.1 or 0.8.4 (and 0.8.3 to 0.8.1): Store → Updates shows "LordOS 0.8.5 is available" with these notes; Update installs it and a restart finishes it. sudo apt update && sudo apt upgrade does the same. No migration runs (ls /var/lib/lordos/migrations is unchanged from 0.8.4); your settings are kept. Tested before the release with the same package built as 0.8.5~rc2: a VMware machine on 0.8.4.1 and a Raspberry Pi 5 on 0.8.4, both with apt, then a restart.
  • The Store's new Artificial Intelligence and Commercial pages add a maker's repository only when you install one of its apps, and remove it when you remove the app.

0.8.4.1-beta - 2026-10-25

An update of 0.8.4 for the Raspberry Pi 5: its bootloader from Settings, and a new Pi image with the HDMI fix, the browsers and the ISO's system packages (0.8.4 held its Pi image back).

Added

  • Settings → Board firmware (Raspberry Pi 5). A new page, only on a Raspberry Pi 5 (and Pi 500, Compute Module 5), for the bootloader that lives in the board's EEPROM: the installed version, the newest one available, whether it is up to date, and Update. After updating it says a restart finishes the job and offers Restart…; the board installs the new bootloader as it starts, keeping its recovery path. This is LordOS's replacement for the bootloader part of raspi-config (ignore rpi-eeprom-update's hint to run it). It runs only the system's rpi-eeprom-update with a fixed set of options, through two closed admin actions: reading the status is open to everyone, updating needs an administrator (docs/SETTINGS.md, "Board firmware").
  • The bootloader updater in the LordOS repository. rpi-eeprom (the bootloader images and rpi-eeprom-update) and the few Raspberry Pi packages it needs (raspi-utils and its parts, raspinfo, kms++) are now mirrored in lordos.org/apt for arm64, copied from Raspberry Pi's archive only after its signature and every file's SHA-256 check out against a pinned list (tools/release/rpi-mirror.list). A Pi with only the LordOS and Debian repositories gets new bootloaders with the usual updates; PCs never see these packages (docs/UPDATES.md, "Raspberry Pi firmware packages").
  • Browsers in the Raspberry Pi image. Chromium and Firefox ESR come preinstalled, as on the ISO, with the same defaults: a single bar with their tabs and LordOS's window buttons, the LordOS GTK theme and the video settings of Settings → Displays → Video (the defaults are now one script shared by both images, tools/iso/browser-defaults.sh).
  • The rest of the ISO's system packages in the Pi image: automatic time (systemd-timesyncd), printing (cups, avahi-daemon), exFAT and NTFS drives, power profiles, the MIME database and the GTK settings schemas. The first user is also allowed to manage printers (lpadmin), as on a PC.

Fixed

  • Raspberry Pi 5 on an HDMI monitor stayed on the text console ("no display device with KMS"). The firmware ignored the display driver line in the image's config.txt because it came before the display_auto_detect and camera_auto_detect lines; it now comes after them. Together with 0.8.4's longer wait for the display driver, the desktop shows on HDMI at the first boot.
  • The Pi image's clock. The board keeps no time without a battery and the image had no network time client, so it started months behind and every update failed with "not valid yet". It now sets the time from the network at boot.

Known issues and limitations

  • A monitor plugged in after boot stays black until the board is restarted: the login screen doesn't follow the kernel's display events yet. Connect the HDMI monitor before switching the board on. Fixed for 0.8.5.
  • A Pi set up from the 0.8.3 image has no network time client: if Store → Updates fails, set the time in Settings → Date & Time first, then install systemd-timesyncd from the Store.
  • The bootloader release (Default or Latest) is shown but not changed from Settings: it is /etc/default/rpi-eeprom-update, a file of the rpi-eeprom package.
  • Raspberry Pi archive on the Pi image. The image still lists Raspberry Pi's archive, limited by apt priorities to the firmware, kernel tools and utilities; the Store's own package engine does not read apt priorities yet, so "Update all" there may take Raspberry Pi's builds of a few packages (such as Chromium or BlueZ) instead of Debian's. apt follows the priorities.
  • install.sh does not install browsers (on a Raspberry Pi OS Lite or any Debian 13): install Chromium or Firefox ESR from the Store if the system has none (docs/INSTALL-DEBIAN.md).

Upgrading

  • From 0.8.4 (and 0.8.3 to 0.8.1): Store → Updates shows "LordOS 0.8.4.1 is available" with these notes; Update installs it and a restart finishes it. sudo apt update && sudo apt upgrade does the same. No migration runs (ls /var/lib/lordos/migrations is unchanged from 0.8.4); your settings are kept. On a PC nothing else changes.
  • Raspberry Pi 5: after the update, Settings shows Board firmware. If it says "The bootloader tools are not installed", Install adds rpi-eeprom from the LordOS repository. The browsers and the other image packages above are not added to a board that is already set up: install them from the Store.

0.8.4-beta - 2026-10-19

Added

  • Settings → Appearance → «Browsers: tabs in the title bar». One switch for both preinstalled browsers: on (the default), Chromium and Firefox draw a single bar with their tabs and LordOS's window buttons; off, they use the LordOS frame. It changes the setting in your own browser profiles and applies the next time each browser opens; if Chromium is open, it waits until you quit it. Chromium profiles from before this version that still use the LordOS frame are shown on the page, with a button to change them too. A choice you made yourself in a Firefox user.js file is left alone, and choices you make later in the browsers' own settings stick.
  • Remote desktop as video. The remote desktop now arrives as real video (H.264, or VP8 when the browser has no H.264) with the session's sound (Opus), instead of images. Still areas are then made pixel-perfect with lossless tiles, so text stays sharp. Dragging a window went from about 23 frames per second and 12.5 Mbit/s to about 29 frames per second and under 1 Mbit/s, and the connection's own process from 57 % of a core to 2 %. The session encodes once (on the graphics card with VA-API when it can, else in software) for every viewer of that session; the screen keeps being composed on the graphics card while someone watches. Keyboard, mouse and clipboard go over a WebRTC data channel. Video is the only way the remote desktop works (see Removed).
  • The remote desktop works where UDP is blocked. Besides UDP, the video also connects over TCP on the remote desktop's own port (5673), so a firewall or VPN that only lets that port through is enough; on the local network nothing else is needed. With UDP blocked, video plays about 2 s after the page loads.
  • The remote desktop reconnects by itself. When the network drops or changes, the page keeps the last frame with a "Reconnecting…" note and recovers on its own, without signing in again: first on the same encrypted connection (back within a fraction of a second once the network returns, after a 20-second outage), then with a new one, then with a new connection to the computer after longer outages (75 seconds were tested).
  • Clear messages when it can't connect. If there is really no way through, the page says why (nothing gets through over UDP or TCP, the encrypted channel couldn't be set up, the connection was lost, the browser can't play the video…) and what to do, with a Try again button. A browser without WebRTC, or without H.264 and VP8, gets a page that lists what it needs.
  • Settings → Sharing → Connection: add public STUN servers and a TURN relay for connecting across networks, reached over UDP, TCP or TLS (port 443 works). Over TLS the relay's certificate is checked against the system's certificate authorities and its name, or against a fingerprint you paste for a relay with its own certificate. A built-in STUN server covers the local network, and nothing reaches outside servers unless you add them. The relay's password stays on the computer, readable only by the system, and is never sent to the browser.
  • LordOS Imager. Write LordOS to an SD card or a USB stick and have the Raspberry Pi 5 start ready to use: choose the device (Raspberry Pi 5, or a PC from a USB stick), the system image (the latest signed release, downloaded once and resumed if interrupted, or a file of your own with a clear warning) and the drive (only SD cards and USB drives; internal disks and the disk the computer runs from are never shown), then customise the first boot: computer name, language, time zone, keyboard, your account (only a hash of the password goes on the card), Wi-Fi (only the derived key), SSH with keys or a password, LordOS remote desktop (local network only), Bluetooth, Lord Default or Classic in light or dark with your accent, and cooling (case with a fan, active cooler, passive case or nothing, with a matching profile and an optional mild overclock with a fan). Lumo gives a tip at every step and celebrates at the end. Every official image is checked against the LordOS release signature before anything is erased, and every card is read back and compared after writing; cancelling clears the card. In English, Spanish and Portuguese, with keyboard navigation. See docs/IMAGER.md.
  • The LordOS Imager for other computers: the same app for the three common desktop platforms (Tauri, about 6 MB), sharing the interface with the one in LordOS, attached to this release as lordos_imager_0.8.4_universal.dmg (both processor families, signed and notarized, so it opens without warnings), lordos_imager_0.8.4_amd64.deb (needs udisks2 and a polkit agent) and lordos_imager_0.8.4_x64_setup.exe (not code-signed yet, see Known issues), all listed in the signed SHA256SUMS.
  • First-run file on the Raspberry Pi (lordos-firstrun.txt on the boot partition): read once on the first boot by lordos-firstrun, strictly validated (nothing is applied if any part is wrong), then overwritten and deleted. See docs/RASPBERRY.md, "First boot".

Security

  • The imager's privileged part is four closed actions: downloads run curl as the user against two fixed URL shapes; writing accepts only a whole removable disk whose size, model and serial are re-checked right before it is opened exclusively, decompresses with xz running as the user, and never writes an official image whose signature or hash doesn't match. Over 2 TiB is refused.
  • Saved Wi-Fi networks may hold a derived WPA2 key (psk=) instead of the password.

Changed

  • Browsers with a single top bar. Chromium and Firefox now draw their own bar, with the tabs in the title bar and the window buttons inside it, instead of the LordOS frame on top. In Chromium the buttons are LordOS's traffic lights (from LordOS's GTK theme, sized like LordOS's own frame); Firefox keeps its own button style. Both put them where the LordOS theme does: on the left in Lord Default, on the right in Classic, and follow a theme or light/dark change live. Going back to the LordOS frame is one switch in each browser («Use system title bar and borders» in Chromium, «Title Bar» in Firefox), and it now applies right away, without reopening the window. Systems upgraded from 0.8.3 get the new defaults for Firefox, and for new Chromium profiles; an existing Chromium profile keeps its frame until its user switches (or uses the new switch in Settings).

Removed

  • The remote desktop's image mode. The screen no longer travels as PNG/JPEG images over the connection to the browser, not even as a fallback: it is WebRTC video, which reconnects on its own and explains any failure instead. The «images only» switch in Settings → Sharing is gone, and lord-sessiond now always needs libsrtp2 and usrsctp (the lordos package depends on libsrtp2-1 and libusrsctp2). While the video plays the CPU use is the same as before (the image path was already idle then); what's gone is the image work before the video starts and on networks where the video couldn't connect.

Fixed

  • Raspberry Pi 5 on an HDMI monitor: "LordOS could not show its desktop" on the first boot. The login screen gave up when the display driver (vc4) wasn't there yet as LordOS started, and the board stayed on the text console. LordOS now loads the driver itself and waits up to 30 s for it, and the session waits up to 30 s more for a display device before falling back.
  • Two title bars in Chromium. With «Use system title bar and borders» off, Chromium drew its own bar and LordOS still put its frame on top: the compositor now honors the frame an app asks for (xdg-decoration and the GTK 3 decoration protocol), also when it changes while the window is open; the window keeps its place, size, maximized state, focus and Dock entry.
  • Linux app windows disappeared after switching between Lord Default and Classic (they stayed open but invisible): they now come back in the new theme, maximized ones still maximized.
  • The window menu of apps that draw their own bar. A right click on a GTK app's own title bar now opens the theme's window menu (Minimize, Zoom, Close; in Classic also Restore, Snap layouts and the snap halves).
  • Raspberry Pi 5: blocking an app now closes its open connections (a known issue in 0.8.3), as on a PC, instead of leaving them stalled until the app's own timeout. The LordOS Pi kernel is rebuilt as 6.18.57-lordos.3-rpi-2712 (6.18.57-3+lordos): the same Raspberry Pi source and options as before (Landlock, the BPF LSM, BTF, Yama) plus sock_diag socket destroy (CONFIG_INET_DIAG_DESTROY, CONFIG_INET_UDP_DIAG), so lord-netperm closes TCP and QUIC connections a new rule denies within a fraction of a second. Each kernel revision now installs as its own package next to the previous one, so the previous kernel stays bootable as a fallback (one line in config.txt, see docs/RASPBERRY.md). The image build and verify-board check the kernel has it. On a Pi 5: TCP downloads and an idle session end 0.04–0.37 s after the rule changes, an HTTP/3 (QUIC) download 0.08 s.
  • build-kernel.sh cross-compiles the Pi kernel on an x86-64 Debian 13 (the arm64 Debian packages, no arm64 build dependencies needed).

Known issues and limitations

  • The remote desktop needs a browser with WebRTC and H.264 or VP8 video. Current desktop and mobile browsers have both; a browser without them gets a page that lists what it needs, since the image mode is gone (see Removed).
  • No Raspberry Pi 5 image in this release. The 0.8.3 image could stay on the text console on an HDMI monitor at its first boot (see Fixed); the 0.8.4 image with the fix is built but has not been booted on a board with a monitor yet, so it is not published until it has. Until then the LordOS Imager offers the 0.8.3 image for the Pi, which may show that message on its first boot. Raspberry Pi OS Lite plus curl -fsSL https://lordos.org/install.sh | sh gives a working LordOS 0.8.4 on the Pi 5, and installed boards update as usual.
  • Raspberry Pi 5 boards updated from the Store or apt keep their kernel. The LordOS Pi kernel is not in the APT repository yet (docs/UPDATES.md, "The Raspberry Pi kernel"), so the -3 kernel, which closes the connections of a blocked app, comes with the next Pi image. On a board with the -2 kernel the firewall still drops a blocked connection's packets, but the app only sees it end at its own timeout, as in 0.8.3.
  • The LordOS Imager: the desktop downloads were tested writing to disk images, not yet to real SD cards or USB sticks; the first-run file was applied to the 0.8.4 Pi image in a test (every setting checked), not yet booted on a board. The installer for the third platform is not code-signed yet, so the system warns before running it the first time; its SHA-256 is in the signed SHA256SUMS. Images up to 0.8.3 ignore the first-run file and start in setup mode.
  • Existing Chromium profiles keep the LordOS frame until you switch them (Settings → Appearance lists them, with a button); new profiles and Firefox get the single bar.
  • Monitor → Network's second generation, listed for 0.8.4 in the roadmap, is not in this release.
  • The other known issues of 0.8.3 still apply.

Upgrading

  • From 0.8.3, 0.8.2 or 0.8.1: Store → Updates shows "LordOS 0.8.4 is available" with these notes; Update installs it (with its two new libraries, libsrtp2-1 and libusrsctp2), and a restart finishes it. sudo apt update && sudo apt upgrade does the same (apt-get upgrade keeps lordos back because of the new dependencies; apt upgrade or apt-get install lordos installs it). The update runs migration 005 once (the preinstalled browsers' default bar; from older versions the earlier migrations run first); ls /var/lib/lordos/migrations lists the ones applied. Your settings are kept.
  • Browsers after the update: Firefox draws its single bar the next time it opens (unless you chose «Title Bar» yourself); new Chromium profiles do too. To get it in an existing Chromium profile, or to go back to the LordOS frame for both, use Settings → Appearance → «Browsers: tabs in the title bar».
  • Remote desktop after the update: it is WebRTC video only. The «images only» switch is gone from Settings → Sharing; nothing else changes in its settings (port, addresses, the lockout). Where only the remote desktop's port is open, the video now connects over TCP on that port.
  • Raspberry Pi 5: lordos updates from the Store or apt like on a PC. The -3 kernel comes with the next Pi image (see Known issues); on an updated board uname -r still shows 6.18.57-lordos-rpi-2712. Building and installing it by hand next to the old one is described in docs/RASPBERRY.md, "Switching kernels on a board".
  • From 0.8.0 (once): run curl -fsSL https://lordos.org/install.sh | sh (a system installed from the 0.8.0 ISO has no curl: run sudo apt update && sudo apt install -y curl first). It upgrades in place to 0.8.4, runs migrations 001 to 005 and adds the LordOS repository; from then on new versions come through Store → Updates.

0.8.3-beta - 2026-10-19

Added

  • X11 apps. Programs that only speak X11 (xterm, Java/Swing apps, many games and older tools) now open in LordOS through Xwayland (the xwayland package), with the theme's window frame, their icon in the Dock (matched to their launcher by WM_CLASS), menus and tooltips above everything, fullscreen, minimize and close, and LordOS's cursor. Xwayland only starts when an X11 app connects and stops 10 seconds after the last one closes. LordOS's own X window manager is written in C and speaks the X11 protocol itself, without new libraries in lord-server.
  • Clipboard with X11 apps, both ways, for the normal clipboard and the primary selection (select to copy, middle click to paste); large copies and images included.
  • Primary selection for Wayland apps (middle-click paste between GTK, Qt and other apps).
  • Classic, a second full appearance. The Classic theme is no longer a template: it is a complete desktop for people used to a taskbar layout, with the same apps as Lord Default. A centered taskbar (or aligned to the start, on any side of the screen) with the start button, search, task view, the pinned and open apps and the Trash last; a start menu with a search field that searches like the system search (apps, settings, files, notes, the calculator, Help), a grid of pinned apps you arrange with a right click, recently used apps, every app A–Z, and the user and power button (Lock, Switch User, Log Out, Restart…, Shut Down…); a tray with quick settings (network, Bluetooth, Do Not Disturb, Night Light, dark mode, transparency, volume, what is playing, battery) and a notification panel with a month calendar; notifications above the taskbar; and a window frame with the title at the start and the buttons at the end. Everything is our own design: LordOS icons drawn by the theme, Inter, the LordOS wallpapers and names. Switch between the two in Settings → Appearance → Desktop style, live and without logging out: the windows that were open come back in the new one. Light and dark mode, right-to-left languages and the accent colors work in both. See docs/DESIGN.md, "Classic".
  • Window snapping. In Classic, drag a window to the left or right edge to fill that half of the screen, to a corner for a quarter, or to the top edge to maximize it; a preview shows where it will go. Hovering over the maximize button offers layouts (halves, two thirds and one third, thirds, quarters), and Super+arrows move the window in front between them. Dragging a snapped window away gives it back its size. See docs/WINDOWS.md, "Snapping".
  • Task view. Super+Tab (or the taskbar button) shows every window side by side, live and smaller, over a dimmed desktop: click one to bring it to the front, or close it from there.
  • Themes restyle every app. The shared controls (buttons, fields, segmented controls, sidebars, menus, tooltips, grouped forms, confirmations and the Restart/Shut Down sheet) now take their shape from the theme: corner radii, a light or accent menu highlight, an accent bar or a fill for the selected sidebar row, an underline or a ring on the focused field, and bordered buttons. Lord Default looks as before; Classic uses smaller radii, borders and subtle highlights. Isolated apps (Mail, Calendar, Contacts, Reminders, Passwords) follow it too.
  • Remote desktop: allowlist, blocklist and temporary blocks. Settings → Sharing chooses who may connect: the local network (the default: private and link-local addresses and connections over a VPN of this computer), only these addresses (the allowlist), or any address; keeps a blocklist of addresses and networks that are always refused; and lists the temporarily blocked addresses with the time left, Unblock and Block permanently. You get a notification when an address is blocked.
  • Monitor → Network shows the remote desktop as one more app while it's on: the browsers connected with their traffic, the recent failed sign-ins (address and the name typed, for administrators), the blocks and the lists, with Block and Unblock.

Changed

  • Settings → Desktop & Dock in Classic adds Taskbar alignment (center or start).
  • The lordos package recommends xwayland, and the ISO and the Raspberry Pi 5 image include it, so X11 apps open out of the box.
  • The theme engine paints a scaled window that contains a blurred surface (a translucent Terminal) at its scaled size; its blur then only shows the window's own content. Before, such a window was drawn at full size during the Dock's minimize effect.
  • Scroll bars stay out of the way. Scroll bars across the system are now thin overlay bars drawn at the very edge of a list or panel: hidden until you scroll (mouse wheel, touchpad, keyboard or dragging the bar) or bring the pointer near the edge, 6 px wide and 10 px under the pointer, fading out a second after the last scroll. They no longer take a strip of their own and never cover text. Settings → Appearance → Show scroll bars: Automatically (the default), When scrolling or Always (the persistent bar, for accessibility). With Reduce motion they appear and disappear without a fade; in right-to-left languages they are on the left. The Classic theme draws them with its own squarer style, and the Terminal's history bar matches.
  • Monitor → Network: a tidier detail panel. The right panel's sections (Process, Rule, Connections, Data, Ports and protocols, Destinations, and the summary's) fold with a click on their header and stay folded the next time. App names in "Top apps by traffic", the app list and the panel header wrap to two lines instead of being cut, long destinations wrap too, and the app list gives the name more room (the counts moved next to the traffic bar, the Data and Rule columns are narrower).
  • Debian's smartd stays off. Installing smartmontools from Disks no longer leaves its monitoring daemon polling the disks every 30 minutes; Disks and the Monitor read SMART on demand. Administrators can opt back in (docs/SYSTEM.md, "smartd").
  • Remote desktop now accepts the local network only by default. Connections from public internet addresses are refused unless you choose Any address (or list them) in Settings → Sharing; a VPN of this computer still works. Browsers signed in before the update sign in once more (the sign-in cookie changed).

Security

  • X11 apps run in their app's scope, so per-app firewall rules and the Monitor apply to them.
  • X11 apps never see Wayland apps, LordOS's screen, Passwords or the keyring prompt, nor the keys typed into them; what is copied outside X enters X only while an X window has the keyboard, and passwords copied in Passwords never do. Synthetic input between X11 apps (XTEST) is off. Xwayland runs without network, in its own scope. X11 apps can still see each other, as in any X11 desktop (see the privacy documentation).
  • Apps with device or "no files" restrictions get no X display.
  • Clipboard offers to Wayland apps are bound to the selection they were made for and to the app with the keyboard.
  • The per-app firewall applies to open connections, not only to new ones. A rule change used to leave established TCP connections and connected UDP sockets (QUIC) outside the policy until they closed. lord-netperm's packet filter (the cgroup programs that already counted bytes per app) now takes the same decision as at connect time for every packet of an app whose rules deny something, and lord-netperm destroys those sockets over sock_diag netlink (its unit now also allows AF_NETLINK; it still creates no internet sockets). "No incoming connections" now also cuts connections already accepted. The Raspberry Pi kernel build enables CONFIG_INET_DIAG_DESTROY; on a kernel without it the packets are still dropped.
  • Remote desktop: 3 failed sign-ins block the address. For 15 minutes, then 1 hour, then 24 hours if it happens again within a day (IPv6 counted per /64). Blocked addresses are cut before any TLS work and stay blocked after a restart (/var/lib/lordos/remote/blocklist, root only). Accounts are never locked (that would let anybody lock you out); repeated failures for one account only slow it down. Every failure and block goes to the journal (address and a sanitized user name, never the password).
  • Remote desktop: a full security review and hardening (docs/REMOTE.md). The page and the server check every field strictly (user names a-z 0-9 _ - up to 32, passwords 1–1024 bytes); the request, the form, the cookie, the WebSocket and the input messages are parsed strictly and refused otherwise; a wrong user name and a wrong password take exactly the same time; connections that are slow, too many from one address, or from addresses not allowed are closed early; the sign-in cookie is a __Host- cookie stored only as a hash, tied to the password (a password change or lock ends it) and ended for every browser of a user when that user locks the screen; sign-in and sign-out only accept requests from the page itself; TLS 1.2+ with AEAD ciphers only; the part that serves the desktop runs as the user with no shared state, no other descriptors and no way back to root. root can never sign in remotely.

Fixed

  • Java (AWT/Swing) windows were blank or shifted (non-reparenting window manager).
  • The Passwords and Backups icons sat off center in the Dock and the launcher.
  • Blocking an app now cuts the connections it already has open. Turning an app's rule off in Monitor → Network (or adding a deny rule for a destination or domain, or a restriction such as "no internet") counted its new connections as denied, but what was already open kept flowing: a video kept playing over its established TCP and QUIC connections. Now the matching traffic stops within milliseconds: the kernel drops the packets of those connections and LordOS closes them, so the app sees the connection end instead of a stall. Only what the new rule denies is cut: other destinations, the local network under "no internet", and the clients of a server the app runs keep working. Switching the rule back to allow works again at once. The Monitor counts every cut connection as denied and shows the dropped bytes as "Blocked traffic" in the app's details. See docs/FIREWALL.md, "Existing connections are cut".

Known issues and limitations

  • X11 apps need Debian's xwayland package. New installs from the ISO and the Raspberry Pi 5 image, install.sh and apt upgrade bring it (the lordos package now recommends it). The Store's update installs only what the package depends on, so after updating from the Store, install xwayland from the Store (or sudo apt install xwayland) to open X11 apps; Wayland apps don't need it. For the same reason apt-get upgrade keeps lordos back; apt upgrade (or apt-get install lordos) installs it.
  • Raspberry Pi 5: blocked connections stall instead of closing. The image keeps 0.8.2's LordOS kernel, which was built before CONFIG_INET_DIAG_DESTROY; there the firewall drops the packets of a connection a new rule denies at once, but the app only sees the connection end at its own timeout. The next Pi kernel build closes them like on a PC.
  • X11 apps can see each other, as on any X11 desktop; a separate display for restricted X11 apps, drag and drop between X11 and Wayland apps and sharp X11 apps on HiDPI displays come later.
  • The other known issues of 0.8.2 still apply.

Upgrading

  • From 0.8.2 or 0.8.1: Store → Updates shows "LordOS 0.8.3 is available" with these notes; Update installs it, and a restart finishes it. sudo apt update && sudo apt upgrade does the same. The update runs migration 004 once (it stops Debian's smartd if smartmontools left it running; from 0.8.1, migration 003 runs first); ls /var/lib/lordos/migrations lists the ones applied. Your settings are kept.
  • Remote desktop after the update: connections from public internet addresses are refused unless you choose Any address (or add them to the allowlist) in Settings → Sharing; the local network and a VPN of this computer keep working. Browsers that were signed in before sign in once more.
  • From 0.8.0 (once): run curl -fsSL https://lordos.org/install.sh | sh (a system installed from the 0.8.0 ISO has no curl: run sudo apt update && sudo apt install -y curl first). It upgrades in place to 0.8.3, runs migrations 001 to 004 and adds the LordOS repository; from then on new versions come through Store → Updates.

0.8.2-beta - 2026-10-19

Added

  • New wallpapers. Eleven original LordOS wallpapers in three categories: Signature (Crystal Crown, Eternal Dawn, Royal Flow, Royal Waves, Violet Horizon), Lumo (Celestial, Aurora) and Cosmos (Event Horizon, Infinite Galaxy, Solar Odyssey, Stellar Voyage), created by iPERFEX with an AI image generator. Settings → Wallpaper now lists every wallpaper grouped by category, with the previous four gradients as "Gradients". They are installed once in /usr/share/backgrounds/lordos/ as high-quality JPEG (about 4 MB in total) with small thumbnails for the pickers, and a higher-resolution version added later is used automatically on the screens that need it.
  • Suggested for your computer. Store → Discover now starts with packages for the hardware LordOS finds in the computer, each with the reason it appears ("We detected a printer from HP connected by USB"): the guest tools of a VMware or QEMU virtual machine, the proprietary graphics driver for an NVIDIA card (labeled as not free software, never preselected, with what changes: DKMS, Secure Boot key enrollment, older cards, and that the free nouveau driver stays the default), vendor drivers for USB printers and scanners, driverless USB printing (ipp-usb), the Raspberry Pi 5's board tools, and the firmware package a Wi-Fi, Bluetooth, network or graphics device asked for and didn't find. One click shows the usual plan and installs through the package engine; "Don't suggest again" hides a card for good. When something new is suggested, the Store's Discover item shows a count and one notification says so. For a VirtualBox virtual machine the card explains that its guest utilities aren't part of Debian 13. Detection only reads the kernel's hardware files; nothing is sent anywhere. The rules are data (assets/store/suggestions.json); see docs/PACKAGES.md.
  • Monitor → Disks: each disk's temperature and health. The Disks tab now shows every physical disk's live temperature, read from the kernel without root: NVMe and M.2 drives through the nvme driver's own sensor (also on a Raspberry Pi 5 with an M.2 HAT), SATA disks through the drivetemp module, which the lordos package now loads at boot. Memory cards, virtual disks and adapters without a sensor say "No sensor", never a made-up value. The chosen disk gets a 30-minute temperature chart with the drive's own limits when it reports them, and an OK / Check / Failing light from a cached SMART summary, with "Open in Disks". Spinning disks are only read while they are in use, so a resting disk is never woken up (docs/MONITOR.md).
  • Disks: the full SMART report with smartmontools. The first time, the health card offers to install Debian's smartmontools through the Store's package engine (an administrator). Then it shows the overall health and why in plain words, temperature and limits, SSD wear (% of its rated life used), power-on hours and cycles, reallocated and pending sectors, every attribute with a plain name, the NVMe health log, the error log, the disk's own temperature history, and short and long self-tests with progress and results. USB disks behind adapters that pass SMART through work too. smartctl runs only through four new closed, validated root helper actions (smart-info, smart-health, smart-test, smart-abort) on real whole disks, at a fixed path, with JSON output (docs/SYSTEM.md).
  • Notifications when a disk gets too hot or its health gets worse, at most once per disk every 30 minutes for heat, and only when the health is worse than last seen. On by default, with a switch in Monitor → Disks.
  • Smooth video in the browser without hardware decoding. Video sites that send VP9 or AV1 make the browser decode them on the processor when the graphics card can't (virtual machines, older PCs, the Raspberry Pi 5), and the video stutters. LordOS now checks at every boot what the hardware decodes (VA-API profiles through lord-media, V4L2 memory-to-memory decoders on ARM, virtual graphics cards count as "no"; cached per boot) and, when VP9 or AV1 is missing, asks the browsers for H.264 instead, which is far lighter to decode. Settings → Displays → Video in the browser: "Optimize video for this computer" (Automatic by default, Always, Never) and "Lower quality automatically when video stutters" (off by default). Nothing is sent anywhere (docs/VIDEO.md).
  • Our own small browser extension (/usr/share/chromium/extensions/lordos-video, MIT), loaded by Debian's Chromium: on YouTube it reports VP9/AV1 as unsupported so the site sends H.264, and when a video keeps dropping frames it shows a small notice that offers a lower quality (or lowers it by itself, if enabled). Its settings come from a managed policy written by the closed admin action video-optimize (fixed text, no user text). Firefox ESR only loads signed extensions, so for now it gets AV1 turned off through a default preference (it then uses VP9); the extension for Firefox waits for signing.
  • Allow or block each destination inside Monitor's app rows. Open an app in Monitor → Network and every name it reached (or address, when the system resolver gave no name) has its own allow/block switch, showing what the app's rules decide for it right now and why ("By the rule *.example.com", "Follows this app's default", "Blocked by this app's restrictions"). A click writes, flips or removes the rule for exactly that name, the same rule Settings → Privacy → Network rules by app shows, and lord-netperm applies it at once. Long lists show eight and "N more…"; rows keep their place while the list is open (docs/MONITOR.md).
  • Traffic history. The Network tab's chart now zooms out from the live minute to 1 hour, 24 hours, 7 days and 30 days, steps back and forward one window at a time and has Now; with an app selected its own chart follows the same window, and the summary lists the apps that moved the most in it. Your session records bytes received and sent per minute (7 days) and per hour (30 days), for the computer and for each of your apps, in a small file in your home folder (~/.local/state/lordos/net-history.bin): never an address, a name or a country. Settings → Privacy → Monitor has Keep a traffic history (on) and Clear History (docs/MONITOR.md).
  • About LordOS shows a "System app" badge and the state of the system code: "Verified", or "Development build" for an unsigned development tree.
  • lord-server --check-code [<folder>] checks a whole installed tree against the signed manifest (troubleshooting, and the .deb build).
  • SHA-256 uses the CPU's SHA-256 instructions on the Raspberry Pi 5 (5× faster there), and the portable code is about twice as fast.
  • Design study: an immutable LordOS with A/B system images (docs/IMMUTABLE.md). It compares dm-verity system partitions, fs-verity, composefs, OSTree, A/B root partitions and btrfs snapshots against Debian 13, the Store, the Raspberry Pi 5 and LordOS's threat model, and recommends a separate, optional edition: a read-only /usr verified by dm-verity in two slots, one signed boot image per version, automatic fallback to the previous version when an update doesn't start, and /etc and the home folders kept on their own partition. The classic edition, install.sh and in-place updates stay as they are; there is no conversion of existing systems.
  • Experimental build of that design (tools/immutable/, not part of the regular ISO or Raspberry Pi image): a disk image for UEFI virtual machines with the A/B layout, a signed update into the other slot, and a scripted demonstration in which a deliberately broken version fails three times and the machine returns to the previous version on its own. Its payload is a minimal Debian 13, not the LordOS desktop yet; the rest of the plan moves to later versions.

Changed

  • New default wallpaper: new users start on Celestial; anyone who already chose a wallpaper keeps it. The login screen (and the remote login page) now shows Crystal Crown.
  • The Control Center shows the current wallpaper and three from the collection; the rest are in Settings → Wallpaper (Change Wallpaper…).
  • The map's moving dots are cheaper to draw: they are small ready-made images and the map's frame is opaque, so a repaint starts there. Repainting several small rectangles per frame instead of the one box around every change (which halved the animation's cost in our measurements) is in this version but off by default: in one test a minimized window left a grey rectangle on the screen, and correctness comes first. LORD_DAMAGE=multi in lord-server's environment turns it on for testing (docs/MONITOR.md).
  • Isolated apps start faster: the app host is compiled to bytecode once per session, so an app's JavaScript loads in ~23 ms instead of ~110 ms (Mail's window: ~145 ms from the click to its first frame on a 1.8 GHz test machine).
  • The Dock's quick actions and New window now work for the apps that run in their own process; Passwords stays a single window.
  • An isolated app's process is named after the app (mail), not exe, in ps and Monitor.
  • Releases: tools/release/sign-code.sh signs the system-code manifest on the maintainer's machine before the build; make -C server RELEASE=1 builds a lord-server that only runs signed code, and tools/iso/mkdeb.sh refuses to package bundles that don't match (docs/RELEASING.md).

Fixed

  • Long notes no longer overlap. In a row with a part that grows (a list item's text next to its bullet), the layout engine measured that part's wrapped height at the whole row's width, so the last line of a long bullet could be drawn over the next one (Store → Updates, "What's new", and any Markdown list). It is now measured at the width it is drawn at.
  • The app host's read and hash for isolated apps' bytecode moved off the main thread at session start (about 15 ms on a cold start); the bytecode is still compiled from exactly the verified bytes.
  • Package lists after enabling a component. Adding a component (such as non-free-firmware) or a source whose signed release file hadn't changed upstream left the package list as it was ("already up to date"); the index is now rebuilt whenever the set of lists it is built from changes.
  • Isolated apps showed times in UTC instead of the local time zone.
  • Trusting a self-signed certificate for an SMTP server on port 465 pinned it as the IMAP server's, so sending kept failing.

Security

  • Keys typed into LordOS's own prompts no longer reach the Linux app in front. What you typed into the search, the app launcher, a sheet or a system prompt (the keyring password, a permission prompt, the file chooser) was also delivered to the Linux (Wayland) app whose window was in front, so that app could read a password typed into the keyring prompt. While any of them is open, Linux apps now get no keys at all; menus and the clipboard and emoji panels still type into the app (docs/PRIVACY.md).
  • Mail, Calendar, Contacts and Reminders run in their own sandboxed process. Like Passwords and installed apps, each one is now lord-server --app <id> with Landlock, seccomp, no network and its own cgroup scope, instead of running inside the desktop's process. Mail's window can read only its own data folder; your files reach it only through the system's open/save dialog; it cannot open sockets, read the mail cache, the accounts file, ~/.ssh or other apps' data (checked from inside the running process). They reach lord-maild only through lord-server, each with its own list of allowed requests (Calendar cannot read mail) and its own replies and events. Notifications, alarms, Dock quick actions, several windows and opening attachments keep working. Monitor shows each app as its own process with its name and icon, and the firewall's per-app restrictions (lpk:mail, …) apply to it (docs/PRIVACY.md).
  • LordOS checks its own code before running it. Every bundle LordOS runs as its own code — the themes with the shell and every native app, the login screen, the app host of isolated apps and the system apps that run as their own process — is listed with its SHA-256 in /usr/lib/lordos/code-manifest.json, signed with the LordOS release key (Ed25519). lord-server verifies the signature with the public key compiled in, and the hash of each bundle as it loads it, from the same read (no window to swap the file). A bundle that doesn't match is not run: the desktop falls back to another theme and shows "This LordOS component was modified and was not loaded"; with nothing left to load (or at the login screen) a built-in recovery screen explains it and how to repair it, never a blank screen. It protects against changes by non-root processes and offline modification; root can still replace lord-server itself, which phase 3 (fs-verity, A/B images) will cover. Cost on a session start: about 7 ms on a Raspberry Pi 5, 18–34 ms on a 1.8 GHz Xeon VM (docs/SIGNING.md).
  • System apps can't be removed. Store → Installed shows "System app — part of LordOS" instead of Remove for the apps that come with LordOS, and the lordos package is marked Protected so the Store's package engine refuses to remove it.

Known issues and limitations

  • City names on the map. Debian 13 only ships country-level IP databases (geoip-database) and LordOS's own is country-level too, so labels stay countries; no large download was added.
  • Repainting several small rectangles per frame is off by default (see Changed): in one of five tries a window minimized over Monitor's animated map left a grey rectangle until it came back, and the cause is still being looked for. The desktop repaints as in 0.8.1.
  • Firefox ESR gets AV1 turned off but not the video extension, which needs signing first.
  • The immutable edition is a study and an experimental image for virtual machines; its payload is not the LordOS desktop yet.
  • The other known issues of 0.8.1 still apply.

Upgrading

  • From 0.8.1: Store → Updates shows "LordOS 0.8.2 is available" with these notes; Update installs it, and a restart finishes it. sudo apt update && sudo apt upgrade does the same. The update runs migration 003 once (it loads the drivetemp module for SATA disk temperatures); ls /var/lib/lordos/migrations lists the ones applied. Your settings are kept, and a wallpaper you chose stays; the new default (Celestial) is for new users.
  • From 0.8.0 (once): run curl -fsSL https://lordos.org/install.sh | sh (a system installed from the 0.8.0 ISO has no curl: run sudo apt update && sudo apt install -y curl first). It upgrades in place to 0.8.2, runs migrations 001 to 003 and adds the LordOS repository; from then on new versions come through Store → Updates.

0.8.1-beta - 2026-10-19

A maintenance and polish release on top of 0.8.0-beta, and the first one that installed systems can update to in place: from here on, new versions arrive through Store → Updates (or apt) from a signed LordOS repository, with no reinstall. It also brings a Dock you arrange yourself, remote login over SSH from Settings, Restart and Shut Down in the crown menu, process actions and complete traffic accounting in Monitor, Bluetooth on the Raspberry Pi 5, and fixes for typing lag and black windows on the GPU path and for legacy BIOS boot in virtual machines.

Added

  • A Dock you arrange yourself. Drag any app (a LordOS app, an installed package or a Linux app such as Firefox) from the app launcher onto the Dock and it lands where you drop it; drag icons along the Dock to reorder them (the neighbours slide aside); drag one away and hold it for a moment to remove it with a "poof", or use Keep in Dock / Remove from Dock in the menus. Files stays first and the Trash last (it shows when it is full, opens in Files, takes files dropped from Files and empties after a confirmation); Files, Settings and the app launcher can't be removed. The Dock's menu starts with quick actions: an app's own (Settings' sections, Files' folders, Mail's New Message, Monitor's tabs) or a Linux app's desktop actions from its .desktop file. Settings → Desktop & Dock → Reset Dock to defaults puts the theme's apps back. The Classic theme's taskbar works the same way, with a drop line. The arrangement from 0.8.0 is migrated on first login (docs/DOCK.md).
  • Update LordOS from the Store, without reinstalling. Store → Updates now shows "LordOS is available" with the release notes and an Update button, next to Debian's updates; files, settings and accounts are kept, and a "Restart required" notice appears when the new version (or a new kernel) is installed. It works the same on the ISO install, the Raspberry Pi image, Debian with install.sh and servers, and sudo apt update && sudo apt upgrade does the same. An optional daily check (on by default, never installs anything) notifies when something new is available (docs/UPDATES.md).
  • Settings → Sharing → Remote login (SSH). A new switch, off by default on every install, turns the standard SSH server on and off for good (systemctl enable --now / disable --now). The first time, it installs openssh-server through the package engine (the Store's path). The page shows ssh <user>@<address> for this computer and its ED25519 host key fingerprint, and lets you allow all users or only administrators. Root never logs in (PermitRootLogin no in a drop-in shipped by the lordos package). The Raspberry Pi image's ssh switch file keeps working and shows up as on (docs/REMOTE.md).
  • Restart… and Shut Down… in the crown menu (and behind a Power button in the Classic theme's start menu); before, they were only on the login screen. Each opens a confirmation that does it by itself after 60 seconds unless cancelled, lists the apps still open and warns when other users are logged in. The session asks lord-sessiond, which only accepts those two words: any user may do it alone, and only an administrator while other users have sessions open (docs/SESSIONS.md).
  • Monitor → Processes: stop a process and Get Info. Select a row and use the new Stop and Info buttons, the right-click menu, a double click, ❖/Ctrl+I or Delete. Stop asks first, with Quit (SIGTERM), Force Quit (SIGKILL) and Cancel. Your own processes are signalled by the session itself with pidfd_send_signal after checking the process's start time, so a reused PID is never hit; another user's or root's need an administrator and go through two new fixed, validated root helper actions (proc-signal, proc-info). PID 1, kernel threads, your session, LordOS's services and helpers and PipeWire can't be stopped: the sheet explains why. Get Info shows memory (real, virtual, shared, private, proportional), statistics (parent, group, CPU time, threads, context switches, page faults, start time, nice, control group and LordOS restrictions), open files and ports (with the addresses of each socket), the executable and the command line, updated every second (docs/MONITOR.md).
  • Bluetooth on the Raspberry Pi 5 image. The on-board CYW43455 controller (on a UART, brought up by the kernel) now works out of the box: the image ships BlueZ, the chip's firmware patch (bluez-firmware), headset audio in PipeWire (libspa-0.2-bluetooth) and a small helper of our own, lordos-rpi-bt@hciN, that routes call audio (SCO) over HCI so headset microphones work. Settings → Bluetooth uses it as on a PC. Scanning is verified on a Pi 5; pairing a device on the board is still to be tested (docs/RASPBERRY.md).
  • Guest tools on VMware. The ISO (and so every installed system) ships open-vm-tools: shutdown and restart from the hypervisor, time sync and the guest's IP address. Its services only run under VMware. Shared clipboard and automatic screen resize are not supported yet (docs/ISO.md).
  • A signed LordOS package repository at https://lordos.org/apt (suite stable, amd64 and arm64), signed with a dedicated OpenPGP key (Ed25519, fingerprint 1DDA F390 107D F264 FA8A 0918 3972 CC6D E4DA 2336) shipped as /usr/share/keyrings/lordos-archive-keyring.gpg; the lordos package adds /etc/apt/sources.list.d/lordos.sources and removes it when uninstalled. Built and signed on the maintainer's machine by tools/release/apt-repo.sh, tested on a staging path first.
  • Migrations between versions. The package's postinst applies each version's system changes once and in order (/usr/lib/lordos/migrate, packaging/migrations/), so skipping versions converges to the same state; each user's settings get the same treatment at login (sdk/settings.js). The first two enable per-app network permissions where they were left off, and keep root's SSH key login on servers upgraded from 0.8.0 (0.8.1 turns root login off).
  • Local repositories in the package engine: a file:/path source (a disk or a USB stick) is read like a download, as nobody, and checked the same way.
  • tools/diag/keylag.sh: where does the typing delay come from? In two minutes it reports the composition mode, the VM and its guest tools and Chromium's complaints, and with lordos.inputdebug=1 on the kernel line (one boot, root only) it times each stage of a key in ms: read by lord-server, delivered to the app, the app's answer, on screen. The trace holds timings only (no key, character or modifier), only for keys sent to Linux apps (never LordOS's own fields, the Terminal, Passwords, login or lock), in a 0600 file in the session's runtime folder, and stops after 120 s (docs/TROUBLESHOOTING.md).
  • verify-board checks Bluetooth and the BPF LSM on a freshly flashed board: the controller on its UART, bluetoothd, the SCO helper, the board address, bpf in the LSM list, the kernel's BTF and lord-netperm.

Changed

  • Monitor → Network: a fluid traffic chart. The sparse per-second bars are now a continuous mirrored strip for the last 60 s: sent above the baseline, received below, one bar per second on a faint track, scrolling smoothly at 4 samples per second, auto-scaled, with the minute's totals as pills. The selected app gets the same chart, each app row a small live activity indicator, and the summary shows "↓ received · ↑ sent" per app and destination (docs/MONITOR.md).
  • Monitor → Network: the map shows which way the traffic flows. Dots travel along each arc, sent from "This computer" to the place and received back, more and faster with the rate; idle arcs are dimmed. Reduce motion shows still markers instead; the animation runs at 12 frames per second, only on screen, and stops when the window is minimized.
  • More audio headroom in virtual machines. When LordOS runs in a VM, emulated sound outputs get 8 periods of 1024 frames, 8192 frames of headroom and interrupt-driven scheduling (a WirePlumber rule that only matches in a VM; real hardware keeps its low latency). On VMware this stopped YouTube stuttering in Chromium (docs/SOUND.md).
  • Background work yields to the desktop after login. Mail sync runs at nice 19 with idle I/O and the thumbnail worker at the lowest I/O priority, so they don't compete with sound and the first windows.
  • The input level meter in Settings → Sound reads a normal 48 kHz stream instead of a 25 Hz peak stream, which in PipeWire ran as a node with a quantum of 1.
  • The LordOS Raspberry Pi kernel gains the BPF LSM, BTF and Yama (6.18.57-2+lordos, same Raspberry Pi source as 0.8.0's -1): CONFIG_BPF_LSM, CONFIG_DEBUG_INFO_BTF (from pahole; modules stripped, no debug package) and CONFIG_SECURITY_YAMA. The active LSM list on the Pi is now capability,landlock,yama,bpf.

Fixed

  • Typing no longer lags in Chromium and Firefox on GPU composition. A Linux app's new frame is only a texture on the GPU path, and a display with no other change was not flipped, so a typed character appeared only when something else on the screen moved (up to ~1 s later; Firefox looked frozen), and Chromium logged "buggy presentation feedback". Every GPU display now presents an app's new content in the next frame; a frame shown by a modeset gets its presentation feedback at once; and with nothing drawn (screen off, session away from the monitor) apps still get their frame callbacks once a second. Measured with Chromium: p50/p95 from the key to the screen 949/1866 ms before, 18/25 ms after; also in 0.8.0. Seen on VMware, reproduced on Proxmox (docs/TROUBLESHOOTING.md).
  • Linux app windows are no longer black after the login screen or a lock. With GPU composition, coming back to the monitor creates a new GPU context, but each window's buffers were still drawn with their textures from the old one: Chromium's window stayed black while its audio kept playing. Imports now belong to one context and are made again, windows keep their last frame while the session is off the monitor, and apps get the new dmabuf formats (docs/GPU.md).
  • Monitor → Network counts all of an app's traffic, UDP and QUIC included. Per-app bytes came only from the TCP sockets open at that moment, so UDP — and with it QUIC: HTTP/3, a browser playing a video — counted nothing, and a closed connection took its bytes with it (a browser streaming music showed 13 KB). lord-netperm now counts every packet of each app's sockets in the kernel (two cgroup_skb programs, both directions, loopback excluded) and sends bytes and rates per app and per address every second: 98.7–98.8 % of the interface's counters in the tests (an HTTP/3 download, a browser on a video site), about 0.5 µs per packet and no measurable cost on TCP (docs/FIREWALL.md).
  • The menu bar names a Linux app, not its window. Next to the crown it showed the window title (for a browser, the whole page title); it now shows the app's short name, "Chromium", in every language. The Dock tooltip and Linux app notifications use the same short name; a real translation of the name (e.g. "Archivos") still shows, and a window without a .desktop file is named after its app id. The window's own title bar keeps the title.
  • Menus are always above the Dock. With the Dock on the left, the crown menu opened underneath it and the Dock took its clicks; select lists inside apps (Passwords' category list) were drawn under the form fields after them. The desktop now has one stacking order, in layers (Dock < menu bar < fullscreen < launcher < menus and popovers < sheets < notifications < tooltips < drag images < system prompts), and clicks follow it, in every Dock position, light and dark, RTL and the Classic theme (docs/LAYERS.md).
  • No lighter band in the menu bar after a menu or the Control Center closes. The menu bar's background blur read the screen around it, and outside the repainted area that still held the bar's previous frame, so the repainted part came out lighter until something else redrew the bar. Now a change that touches a blurred surface, or the margin its blur reads, repaints the whole surface (the GPU path composites the same canvas; engine-test checks it against a full repaint).
  • The Network tab's detail panel no longer hides values under its scroll bar. The panel keeps a strip for the bar, and a label and value that don't fit on one line go on two instead of running over the next row (es/en/pt, right to left, minimum window size).
  • The live ISO boots with legacy BIOS again. 0.8.0 triple-faulted on VMware (and hung at the boot menu on QEMU's VMware-compatible display) when booting with BIOS firmware: GRUB's graphical terminal corrupted its own memory at 640×480 with the theme's proportional font. The theme now uses GRUB's fixed-width font for the terminal and BIOS boots ask for 1024×768 first; UEFI is unchanged. Installed systems get the same theme fix (docs/ISO.md).
  • No silent black screen without a KMS display. When there is no display device with kernel modesetting (for example QEMU's VMware-compatible display), the text console now says so and suggests a display that works; vmwgfx only loads on VMware itself, so the console stays visible elsewhere.

Security

  • "No Bluetooth" for Linux apps is enforced on the Raspberry Pi 5 (a known issue in 0.8.0): lord-netperm loads its Bluetooth socket program there as on a PC (npverify-test 37/37 on the board), and a process in a restricted app's scope gets EPERM from socket(AF_BLUETOOTH) while the same call outside it works.
  • kernel.yama.ptrace_scope = 1 applies on the Raspberry Pi 5: 0.8.0's Pi kernel had no Yama, so any process could attach to another of the same user there.
  • Root can't log in over SSH by default. The lordos package ships /etc/ssh/sshd_config.d/10-lordos.conf with PermitRootLogin no, for the new SSH switch and for an SSH server installed any other way; a server upgraded from 0.8.0 that is administered as root with a key keeps key-only root login (see Upgrading).

Known issues and limitations

  • On the Raspberry Pi 5, pairing a Bluetooth device and a headset's audio have not been tested on the board yet; scanning works. The Pi 4 kernel in the image (-rpi-v8) is still 0.8.0's, without the BPF LSM, so "No Bluetooth" is not enforced on a Pi 4 (docs/RASPBERRY.md).
  • Kernel updates on the Raspberry Pi come with a new image, not through Store → Updates: the LordOS Pi kernel is not in the repository until the image can fall back to the previous kernel (docs/UPDATES.md). The lordos package itself updates on the Pi like anywhere else.
  • On VMware, shared clipboard and automatic screen resize are not supported yet (open-vm-tools-desktop targets X11). QEMU's VMware-compatible display has no kernel modesetting: use the standard VGA or virtio display there.
  • No metered-connection setting yet: turn off Store → Updates → Check for updates automatically on a metered link.
  • The other known issues of 0.8.0 still apply, except the two fixed above (the Pi 5's "No Bluetooth" and the built-in updater).

Upgrading

  • From 0.8.0 (once): run curl -fsSL https://lordos.org/install.sh | sh again (a system installed from the 0.8.0 ISO has no curl: run sudo apt update && sudo apt install -y curl first). It upgrades in place (keeps users, settings and the login setup) and its package adds the LordOS repository; from then on new versions come through Store → Updates or apt. Or add the repository by hand and sudo apt update && sudo apt install lordos (docs/UPDATES.md).
  • On a server administered as root with an SSH key, the upgrade keeps root's key login (/etc/ssh/sshd_config.d/09-lordos-root-keys.conf) even though 0.8.1's default is no root login; delete that file to apply the default.
  • From 0.8.1 on, Store → Updates shows each new version with its notes and installs it; sudo apt update && sudo apt upgrade does the same. Each version's changes to the system run once as migrations (ls /var/lib/lordos/migrations lists the ones applied), so skipping a version is fine. A restart finishes the update.

0.8.0-beta - 2026-10-18

LordOS is a free GNU/Linux distribution based on Debian 13 ("trixie") with its own desktop environment. Debian provides the kernel, the drivers, Mesa, PipeWire, CUPS, BlueZ and every package in the archive, with Debian's security updates. On top of that LordOS ships its own graphical layer: a display server and Wayland compositor written in C that drives the screen and input straight from the Linux kernel, its own interface engine running React, a full desktop and 29 native apps. GTK, Qt and other Wayland apps (Chromium and Firefox are preinstalled) open as ordinary windows next to the native ones.

This is the first public release. It documents everything LordOS has today, not only what changed since the last internal build. It is a beta: most of it works and is tested in virtual machines, but some parts have not been tested on real hardware yet (see Known issues and limitations). The project paper, docs/PAPER.md, gives the big picture.

Highlights

  • Light enough for modest hardware. The whole system idles at 465–487 MB of RAM and 99 % idle CPU, the live system boots to the desktop in 16.3 s, and lord-server (the display server with the whole desktop) uses 32–36 MB (measured in the final ISO test, see docs/ISO.md).
  • A desktop of its own, built on Debian and Wayland. Its own display server and Wayland compositor in C, its own React interface engine, two themes, a Dock, search, a clipboard history, several displays with sharp HiDPI, and smooth window moving even without a GPU.
  • Private by design. Third-party apps run sandboxed (Landlock, seccomp, cgroup v2) behind a permission broker, with system-drawn prompts for the camera, microphone, files, screen and network. Passwords and other sensitive windows are black in screenshots, recordings and the remote desktop.
  • A visible, per-app firewall. Allow or block the network per app, by domain, address or network, enforced in the kernel with cgroup BPF, and see every app's connections on a world map in Monitor. Linux apps can also be denied the camera, microphone, USB, Bluetooth, screen, notifications and your files.
  • 29 native apps. Files, Terminal, Text Editor, Notes, Mail, Calendar, Contacts, Reminders, Passwords, PDF Viewer, Photos, Player, Camera, Recorder, Screenshots, Monitor, Disks, Backups, Store and more, in English, Spanish and Portuguese, right to left included.
  • Install it your way. A live and installable ISO for 64-bit PCs (UEFI and BIOS), a Raspberry Pi 5 image, or one command on an existing Debian 13. Every release file is listed in an Ed25519-signed SHA256SUMS and comes with an SPDX SBOM.
  • Every language, every script. Full Unicode bidi, Arabic, Indic and about 80 more complex scripts shaped by our own engine, and Korean, Japanese and Chinese input methods.

Added

Desktop and display

  • Display server (lord-server): our own DRM/KMS modesetting with double buffering and page flips, our own evdev input, and a 2D rasterizer with antialiased rounded rectangles, shadows and blur. It drops root after opening the display and input.
  • GPU composition with Mesa (EGL, GBM, GLES2), linux-dmabuf, direct scanout for fullscreen apps and a hardware cursor plane; the CPU path stays as the fallback and as "safe mode" (docs/GPU.md).
  • Interface engine: QuickJS embedded in the server, a native node tree, a CSS subset, our own flexbox layout (with flexWrap), text ellipsis, per-side borders, logical (start/end) edges, scale and rotate transforms, damage tracking and cached shadows. React 19 runs on it through the stock react-reconciler. Painting got faster before the release: a full-screen paint went from 12.5 to 4.8 ms, and dragging across two displays from 11.3 to 2.5 ms per frame.
  • Wayland compositor: GTK, Qt and other Wayland apps open as LordOS windows with the theme's frame, in the Dock and the app launcher, with a shared clipboard (images too, surviving the source app), xdg-decoration, popups, app cursors, real fullscreen, wp_presentation, wp_viewporter, relative pointer and pointer constraints for games, and fractional scale (docs/WAYLAND.md).
  • Linux apps from the launcher: installed .desktop apps appear in the app launcher (by freedesktop category), the start menu and the Dock, each in its own cgroup scope; "Open With" in Files and default apps per file type.
  • Two themes, "Lord Default" (menu bar, magnifying Dock, Control Center) and "Classic" (taskbar and start menu), switchable live, in light and dark mode with accent colours.
  • Dock at the bottom, left or right, with size, magnification and auto-hide (docs/DOCK.md).
  • Search for apps, files, notes, Store packages, help articles and a calculator, and an advanced clipboard with history (❖V) that keeps passwords out (docs/SPOTLIGHT.md).
  • Moving and resizing windows: pointer motion coalesced to one per frame, moving and resizing done in C, resizing from all four sides and corners, and LordOS's own cursors (docs/WINDOWS.md).
  • Several displays and HiDPI: extend or mirror, each display at 100, 125, 150, 175 or 200 %, rasterized at the display's real resolution, so a 4K panel next to a 1080p one is sharp on both (docs/DISPLAYS.md).
  • Touchpads and touchscreens with our own multitouch driver: acceleration, tap to click, scrolling with inertia, pinch to zoom (Chromium's too) and three-finger swipes (docs/TRACKPAD.md).
  • Sessions (lord-sessiond): LordOS's own login screen, screen lock (❖L), fast user switching, parallel sessions and Settings → Users (docs/SESSIONS.md).
  • Remote desktop from a browser on the local network: open https://<machine IP>:5673 and sign in with a user of the machine. Nothing to install on the other computer. Off by default (docs/REMOTE.md).
  • Notifications for native and Linux apps (org.freedesktop.Notifications), with per-app settings, Do Not Disturb with a schedule, and menu-bar status items.

Apps

  • Files: tabs, four views, freedesktop Trash, Quick Preview, Get Info, background copy and move, drag and drop, colour tags, search, mounted disks, browsing inside archives, Extract Here and Compress (docs/FILES.md, docs/DOCUMENTS.md).
  • Terminal: our own xterm-256color emulator in C with tabs, split panes, profiles and colour schemes, inline images and Sixel, shell integration (bash, zsh, fish), triggers, Instant Replay, tmux -CC with native tabs, ligatures, colour emoji, and sessions that survive a server restart (docs/TERMINAL.md).
  • Text Editor: our own code editor with syntax highlighting, projects, go to file, find and replace and multiple cursors (docs/EDITOR.md).
  • Notes: markdown notes with a reading view and index, images, attachments and emoji, and sticky notes on the desktop; saved in ~/Notes (docs/NOTES.md).
  • Mail, Calendar, Contacts and Reminders: IMAP (with IDLE) and SMTP for any provider, conversations, a unified inbox and categories, HTML mail shown through our own sanitizer with remote images blocked until asked, tracking pixels dropped and deceptive links flagged; CalDAV calendars and reminders, CardDAV contacts, and meeting invitations answered from Mail. A 10,000-message folder syncs in about 2 s (docs/MAIL.md).
  • Passwords, which is also the system keyring: our own encrypted .lvault format (XChaCha20-Poly1305, Argon2id), unlock with a master password, a FIDO2 security key, a key file on a USB stick or a recovery key; 2FA codes, a generator, a security report, Wi-Fi QR codes, KDBX and CSV import, and the freedesktop Secret Service, so Chromium, Firefox and secret-tool keep their secrets there (docs/PASSWORDS.md).
  • Documents: a PDF Viewer (search, outline, annotations saved as a copy, forms, dark pages, printing), Quick Preview for PDFs, fonts and archives, Fonts and Emoji & Symbols (❖.) (docs/DOCUMENTS.md).
  • Printing and scanning: add driverless network printers, a system print dialog with preview, and a Scanner app over eSCL. LordOS speaks IPP to CUPS with its own client and finds devices over mDNS (docs/PRINTING.md).
  • Media: Photos (HEIC, AVIF, WebP, animated GIF, basic editing), Player (video with subtitles, picture in picture, a music library), Screenshots (screen, window or area, annotation, screen recording to MP4), Camera and Recorder. Decoding runs in a sandboxed helper; a 1080p video costs 13 % of a core windowed and 15 % fullscreen (docs/MEDIA.md).
  • Monitor: CPU, memory, network, disks and processes, each app's connections on a world map (country by IP from an offline database), the firewall's rule per app, and Cooling (docs/MONITOR.md).
  • System apps: Disks (SMART health, format, erase, and a bootable USB from an ISO verified with SHA-256), Backups (scheduled snapshots of your home folder, optional encryption, restore by date), Logs (our own systemd journal reader), Clock (world clock, alarms, timer, stopwatch) and Help (searchable articles and a welcome tour) (docs/SYSTEM.md).
  • Store: Debian packages by category with search, a plan of what will be installed, upgraded or removed before anything changes, updates (Debian's security updates included), local .deb files and native .lpk apps. Our own package engine verifies Debian's signed indexes and hands the last step to dpkg (docs/PACKAGES.md).
  • Native .lpk apps, installed without root, each running as its own isolated process (docs/NATIVE-APPS.md), and our own WebAssembly interpreter for them (26,290/26,290 assertions of the official test suite; docs/WASM.md).
  • Settings, Calculator, Characters, About and the Install LordOS assistant on the live ISO.
  • Chromium and Firefox ESR preinstalled as Linux apps, with the LordOS window frame.

Privacy and security

  • App sandbox of our own, without Flatpak, bubblewrap or firejail: Landlock, a seccomp-bpf allow list, no_new_privs, dropped capabilities and a cgroup v2 scope per app (docs/PRIVACY.md).
  • Each .lpk app as its own process (lord-server --app <id>), talking to the desktop only through a broker that checks every call; a malicious test app fails at everything at run time.
  • Per-app permissions with prompts drawn by the system (not the app), stored where the app can't write, managed in Settings → Privacy, and green/orange dots while the camera or microphone is in use. Revoking the camera or microphone stops it at once.
  • Powerbox file picker: an isolated app only gets the file the user picked, never the folder.
  • Protected windows: Passwords and other sensitive windows are black in screenshots, recordings, the remote desktop and thumbnails.
  • Package signing: .lpk apps signed with Ed25519 (our own SHA-256 and Ed25519 code, tested against RFC 8032 and NIST vectors), trust levels in the Store, a signed catalog with revocation, "Modified by you" detection, "Restore original" and "Share my version" (docs/SIGNING.md).
  • Sandboxed helpers: the only programs that link Poppler and libarchive (lord-doc), FFmpeg (lord-media), the mail parsers (lord-maild) and the vault crypto (lord-vault) run with no network, no sockets and no exec, and work only on the file descriptors they are given.
  • Secret clipboard: copied passwords stay out of the history and are cleared after 30 s.

Firewall

  • Per-app network rules enforced in the kernel by lord-netperm, a root service with cgroup BPF programs (connect, sendmsg, bind, socket creation) and its own BPF loader. Rules can allow or block all traffic, a domain and its subdomains, an address, a network, the LAN only, or incoming connections (docs/FIREWALL.md).
  • Settings → Privacy → Network rules by app: each app's default and its rules, in the order they win (the most specific rule wins), with when each last matched, and a sheet that checks what you type as you type it.
  • Monitor → Network: a per-app switch, allowed and denied counters, recent destinations, and "Allow / Block this domain" prefilled with the name the system resolver gave for the address.
  • Restrictions beyond the network: for LordOS apps, no camera, microphone, screen, USB, files, clipboard, Bluetooth or notifications, refused without a prompt and applied live. For Linux apps: no camera, no USB and no Bluetooth sockets (kernel device and LSM programs), no microphone (a PipeWire guard plus the ALSA capture nodes), no notifications, and "no access to your files" (its own user, mount and PID namespace plus Landlock, from the next launch).
  • No screen capture for Linux apps, by design: the compositor offers no capture protocol, there is no X server and no screen-cast portal, and /dev/fb* is denied.
  • Cheap: about 0.5 µs per UDP connect, no measurable cost on TCP connects or throughput, and nothing in the frame loop.

Network

  • LordOS's own networking on top of the kernel, without NetworkManager: rtnetlink, our own DHCP client, Wi-Fi through wpa_supplicant, and DNS (docs/NETWORK.md).
  • The network belongs to the system (lord-netd): it comes up at boot before anyone logs in, survives users logging in and out, and resumes its DHCP lease after a crash.
  • VPNs in Settings → Network: WireGuard (our own netlink and X25519 keys), OpenVPN, IPsec/IKEv2 (strongSwan's charon, driven by our own VICI client), PPTP, and two optional SSL VPN clients (one of them OpenConnect) that are enabled from Settings. Wi-Fi and VPN secrets are kept in the keyring.

Hardware: fans, displays, Bluetooth, power, sound

  • Fan control (lord-fand, from the first boot, before anyone logs in): System, Quiet, Balanced, Performance, Always on and Custom curves, a full-speed override, and Cooling pages in Settings and Monitor with the hardware drawn live, including the Raspberry Pi 5 fan header and the Argon ONE V5 case (docs/FANS.md).
  • Displays: modes from KMS with the monitor's name, a 15-second "Keep these display settings?" revert, settings saved per monitor, rotation, brightness, and Night Light on a schedule from sunset to sunrise (docs/SETTINGS.md).
  • Bluetooth through BlueZ with our own D-Bus client: discover, pair (system-drawn PIN and passkey prompts), connect and forget; headsets appear in Sound.
  • Energy: battery state and health, low-battery notices, power profiles, display off, lock and sleep timers, power button and lid actions.
  • Sound on PipeWire with our own client: outputs, inputs and per-app volume in the Control Center and Settings (docs/SOUND.md).
  • Date & Time (network time or manual) and Default Apps pages in Settings.

Raspberry Pi 5

  • ARM64 is an official platform; the Raspberry Pi 5 is the supported board (4, 8 or 16 GB), the only one we test (docs/RASPBERRY.md).
  • An image for Raspberry Pi Imager (lordos-<version>-rpi5-arm64.img.xz, about 500 MB): Debian 13 arm64, the same LordOS package as the PC, a partition that grows on first boot, and first-boot setup from lordos-user.txt on the boot partition (user, Wi-Fi, SSH and remote desktop switches).
  • A LordOS build of the Raspberry Pi kernel with Landlock (6.18.57-lordos-rpi-2712), pinned over the archive kernel, and tools/rpi/verify-board.sh to check a board after flashing.
  • Separate display and GPU (vc4 and v3d) and optional NEON drawing, bit-identical to the C code.

Install and boot

  • Live and installable ISO for 64-bit PCs, hybrid for USB sticks, UEFI and BIOS: English by default, Spanish and Portuguese entries, safe mode (CPU only) and copy to RAM. Final test image: 964 MB, a 2.5 GB system, built in 14.5 minutes (docs/ISO.md).
  • Install LordOS assistant: language, keyboard, disk (with a strong confirmation), user and summary; it installs in about 2 minutes and boots by UEFI and BIOS. Every value is validated again on the root side and the password never appears in a command line.
  • One command on Debian 13 (amd64 or arm64): curl -fsSL https://lordos.org/install.sh | sh checks the release signature and SHA-256, installs with apt, sets up the login screen and asks before switching the display manager; --uninstall undoes it (docs/INSTALL-DEBIAN.md).
  • Servers and VPS without a screen: curl -fsSL https://lordos.org/install.sh | sh -s -- --remote-desktop (optionally --remote-port N, 1024–65535, default 5673) also turns on the remote desktop, in the same configuration file Settings → Sharing uses, after a confirmation that warns the port accepts logins from the network. Without a display manager the login screen runs headless, so the desktop is reached at https://<server IP>:5673 from a browser, on amd64 and arm64. --uninstall removes the configuration and closes the port (docs/INSTALL-DEBIAN.md, "Servers and VPS").
  • Boot splash and boot menu: a LordOS GRUB theme and a Plymouth splash (the crown with a progress bar) that hands off to the login screen without a black frame or console text.
  • The version and release channel are built into the system and shown in About and Settings → General.

Languages

  • English (default), Spanish and Portuguese across the interface, with live switching and more languages installable as packs, without touching code (docs/LANGUAGES.md).
  • System-wide language and region: Debian's own messages, dates and numbers follow it; every XKB keyboard layout, up to four at once.
  • Complex scripts with our own engine: full Unicode bidi (91,707/91,707 conformance cases), Arabic, Indic, Thai, Khmer, Myanmar and the Universal Shaping Engine (409/409 test sentences identical to HarfBuzz), and a mirrored interface for right-to-left languages.
  • Input methods for Korean, Japanese and Chinese (pinyin), in text fields and the Terminal.
  • Translatable error codes, so errors read the same in every language.

Website and docs

  • lordos.org in English, Spanish and Portuguese: features, apps, gallery, FAQ, the project paper (with PDFs), the release key and install.sh, and complete legal and trust pages (security policy, code signing, licences, privacy, support lifecycle, standards and more).
  • A hero slideshow of 39 real, checked screenshots inside the laptop on the home page, in story order, with play/pause, previous/next, a counter and captions; it pauses on hover, focus and hidden tabs and respects reduced motion. The spec facts sit in a stats row below it.
  • Site navigation: a hamburger menu with a CSS-only drawer on phones (focus trap, Esc), a back-to-top button, a one-slot language dropdown, a dark-mode switch and a centred footer bar; the Debian card covers PCs and servers (amd64 and arm64, with the --remote-desktop hint) and the FAQ has an entry on servers and VPS. The site runs under a strict CSP (no inline styles or scripts).
  • Documentation for every part of the system, indexed in docs/README.md, with the project paper and screenshots from real test runs.
  • Repository policies: SECURITY.md, CONTRIBUTING.md, CODE_OF_CONDUCT.md, issue forms and docs/COMPLIANCE.md.

Brand

  • New LordOS brand: a vector crown logo, app icon and lockups, a Plus Jakarta Sans wordmark, and a brand kit (docs/LORDOS-BRAND.md).
  • Lumo, the LordOS guardian: a vector mascot used in empty states, Store updates, Monitor, Help, the installer and About.
  • Our own names and assets only: a brand check (tools/brand-check.mjs) keeps third-party product names out of the interface and docs.

Changed

  • English is the default language of the interface, the ISO and the installed system; code, comments and documentation are in English (interface text stays translated in assets/locales/).
  • React 19 (from React 18) for the interface engine.
  • Notes keeps its notes in ~/Notes (it was ~/Notas) and moves the old folder there on first run; the SDK's user folders default to the English names when user-dirs.dirs is missing.
  • Only the Raspberry Pi 5 is supported among Raspberry Pi boards; the website and docs no longer mention other models.
  • Visual polish pass of every native app following the LordOS design guide (docs/DESIGN.md, before and after screenshots in docs/polish/).
  • The boot menu drops GRUB's countdown bar and uses a tighter selection band.
  • The README uses the same copy as lordos.org, with measured figures instead of estimates.
  • Linux apps restricted from the microphone, camera, USB or Bluetooth start in their own view, without the session bus or the user manager (no notifications or portals for them), so they can't escape their scope. A restriction set while such an app runs applies fully only after the app is restarted; Settings says so (docs/FIREWALL.md).
  • pipewire-pulse doesn't load modules (/etc/pipewire/pipewire-pulse.conf.d/lordos-no-modules.conf): a module loaded by a restricted app would run outside its restrictions. Apps that load PulseAudio modules at run time (pactl load-module) get an error.
  • kernel.yama.ptrace_scope = 1 (/usr/lib/sysctl.d/50-lordos-ptrace.conf): a process can only trace its own descendants. Debuggers still work on programs they start; attaching to a running process (gdb -p, strace -p) needs sudo.
  • The copyright holder is "iPERFEX and the LordOS contributors" (MIT licence unchanged).

Fixed

  • The network did not come up on the live ISO when every session became headless, and two sessions could start DHCP on the same interface.
  • "Restart" after installing needed two clicks and could leave a black screen (shared mounts of the installer's chroot unmounted the live medium).
  • The English live session started with the Latin American keyboard; the keyboard now follows the boot entry's language.
  • GTK 3 apps drew the light default theme instead of the LordOS look (missing GSettings schemas).
  • The package's copyright file said the licence was undefined; it now carries the MIT text and lists the bundled fonts.
  • The Dock's hit box, audio for newly created users, upgrade-safe helpers, and the login screen now preselects the last user.
  • lord-server survives SIGPIPE when a client hangs up mid-write.
  • Restarting lordos.service left the old login screen running (and, after an upgrade, its old binary); lord-sessiond now stops the login screen's processes when it stops and any leftover when it starts (docs/SESSIONS.md).
  • A crash when a Dock window had no icon.
  • The firewall attributed "last matched" to the wrong rule after a save.
  • Short connections (such as curl) were missing from Monitor → Network; recent destinations are now listed from the firewall's notices.
  • Settings icons drawn blank, GRUB menu borders shown as "?", PipeWire without real-time priority, and ping without root on the live system.

Security

Hardening and findings fixed before this first release. The full review is in docs/SECURITY-REVIEW-0.8.0.md; report vulnerabilities as described in SECURITY.md.

  • Firewall restrictions were stored but not enforced for the camera, microphone, screen, USB, files, clipboard, Bluetooth and notifications. They are now enforced where each resource is handed out, beat any permission grant, and apply live (58 broker checks in tests/broker_restrict_test.c).
  • Escape through systemd-run --user: a Linux app could leave its scope for the user manager. The programs now also cover each user's user@<uid>.service, with no exemption for the user's own audio services, which the app could otherwise move into.
  • App scopes are owned by root, so a Linux app can no longer move itself to another cgroup.
  • "No access to your files" for Linux apps now runs the app in its own user, mount and PID namespace: Landlock alone did not cover unix-socket connect() in kernel 6.12, so an app could have asked the session bus to start something outside the restriction. Its writable folders come only from its desktop id, never from fields a malicious .desktop file controls.
  • PipeWire guard identity comes from the socket's kernel credentials; a forged application.process.id or an unresolvable client is treated as restricted (fail closed).
  • Microphone restriction also covers recording straight from the sound card (ALSA capture nodes), not only through PipeWire.
  • Notifications: only the bus itself can say who sent a notification; forged, failed or late answers drop it.
  • Permission prompts and file pickers use ids generated by the server, so an app can't answer another app's prompt.
  • Mail: HTML goes through our own sanitizer into native views (no web engine), remote content is blocked until asked, and the parsers run in a sandboxed helper with no network of its own; 31,000+ checks including mutation fuzzing.
  • Installer: every value is validated on the root side, the password travels over a socketpair (never argv), is hashed with yescrypt and wiped from memory.
  • Signed releases: SHA256SUMS is signed with the LordOS Ed25519 release key, and the Debian installer refuses to install when the signature is missing or invalid.
  • Remote desktop is off by default and only reachable after the owner turns it on.

Fixed from the security review before this release (high and medium findings; the numbers are the review's, in docs/SECURITY-REVIEW-0.8.0.md):

  • A malicious .desktop file could leave the "no access to your files" view (#1, high): the working directory was entered before the private folders were mounted, so a relative path still reached the real session bus. The directory is now entered inside the view.
  • An app that couldn't be placed in its own scope still ran, unrestricted (#2, high), for unusual desktop ids or when lord-sessiond was unreachable. Desktop ids are now limited to safe characters and length, and inside a LordOS session an app that can't be placed never starts.
  • The microphone guard failed open (#3, high) when its client or node tables filled up or a permission list was too long. It now disconnects clients it can't follow and destroys streams it can't store.
  • A restricted app could record the microphone through a PulseAudio module (#4, high), which ran as the unrestricted pipewire-pulse. Module loading is off (see "Changed").
  • A restricted Linux app could take over an unrestricted process of the same user with ptrace (#5, high). Only descendants can be traced now (see "Changed").
  • Restricted Linux apps could escape through the user's own services (#13, #37, high): two attempts to exempt "the real sound server" under user@ were forgeable, because the user controls their own systemd manager. Nothing under user@ is trusted for who it claims to be any more; apps restricted from the microphone, camera, USB or Bluetooth start in their own view instead (see "Changed"), and the desktop keeps its microphone.
  • "Open with" could hand an app protected folders (#6, medium) such as ~/.config/autostart, firewall.json or ~/.ssh when a parent folder was opened, and a symlink swapped in between the check and the grant could redirect it (#10, medium). Writable grants never cover those folders, hard-linked files are read-only, and the grant is reopened without following symlinks and must still be the checked file.
  • Shared memory, terminals and caches of the session were reachable from the files view (#7, #8, medium): it now has its own /dev/shm, its own pseudo-terminals and IPC namespace, and the font, shader and GStreamer caches are read-only. More folders that other programs run code from are protected (#9), and a missing XDG_RUNTIME_DIR no longer leaves the bus reachable (#11).
  • A USB microphone plugged in while a no-mic app ran was open to it for a few seconds (#12, medium): every sound device not known to be playback-only is now denied in its scope.
  • A user process could pose as the sound server to the microphone guard (#14, #15, #16, medium) with a nested cgroup or another PID namespace. Matching is now exact (cgroup path, sole process, root-owned binary, our PID namespace).
  • The last frame of another user's desktop could be read after a user switch (#17, medium): lord-sessiond now removes the leaving session's framebuffers before handing the screen over.
  • Landlock's socket scoping failed open on older kernels (#38, medium): the files view and the device view now require Landlock ABI 6 and refuse to start the app otherwise, with a notification.
  • Installer and release tools (low): the verified package is reinstalled from a root-owned copy, a missing release key is an error, a validly signed older release can't downgrade an install, and the signing script refuses unexpected file names.

Known issues and limitations

  • Xwayland is not supported: apps that only speak X11 don't start (planned before 1.0).
  • Flatpak is not integrated with the Store, the launcher or the sandbox.
  • The Raspberry Pi 5 image has not been booted on a board yet. The build, the tests and the login screen are verified on the Pi 5 running from its own SD card, but the published image itself is still untested on hardware (docs/RASPBERRY.md).
  • On the Raspberry Pi 5, "No Bluetooth" is not enforced for Linux apps: the LordOS build of the Raspberry Pi kernel has no BPF LSM (CONFIG_BPF_LSM), so the Bluetooth socket program can't be loaded there (lord-netperm reports "bluetooth":false). The network rules and the other restrictions work as on a PC.
  • The clipboard restriction is not available for Linux apps: the Wayland data device is not mediated per app.
  • BlueZ over D-Bus is not mediated: a Linux app restricted from Bluetooth can't open Bluetooth sockets, but can still ask bluetoothd on the system bus to scan, pair and connect.
  • The .lpk signing key is still a development key. Official app packages are signed with it until the final key replaces it; a signed LordOS app repository for the Store is not built yet.
  • Encrypted disks (LUKS) are untested: the splash's password field has only been checked as a static preview, and Disks doesn't create LUKS or LVM volumes.
  • Secure Boot has to be turned off on PCs (signing with a shim is pending).
  • Not yet tested on real hardware: AMD and NVIDIA GPUs, laptop batteries, backlight and lid, real Bluetooth controllers, FIDO2 security keys, printers and scanners, WPA3 networks, and mail providers (OAuth is prepared but disabled).
  • Firewall: no "ask" mode yet (it behaves as silent); domain rules don't see apps that resolve names with their own encrypted DNS (address rules, defaults and restrictions still apply); while a restricted app runs, the systemd-run --user protection restricts the whole user manager subtree, not only the escaped process.
  • Wayland: drag and drop between apps, the primary selection, LordOS input methods inside Linux apps (text-input), xdg-activation and SVG app icons are pending.
  • Accessibility tools (screen reader, zoom, high contrast) are not available yet.
  • No built-in updater for LordOS itself: new versions come from GitHub Releases; Debian packages update from the Store.
  • Switching to a text console (Ctrl+Alt+F2) doesn't work while LordOS runs; the remote desktop has no audio yet; 802.1X/WPA-Enterprise and DHCPv6 are not supported; GRUB shows about a second of black while it loads the kernel.

See the pending items in docs/ROADMAP.md.

Upgrading

This is the first public release, so there is nothing to upgrade from. To install it:

  • On a PC: write lordos-live-<version>-amd64.iso to a USB stick (it is hybrid: dd, or any image writer in DD mode), boot it with Secure Boot off, try LordOS live, and open Install LordOS to install it to a disk. The whole disk is erased (docs/ISO.md).
  • On a Raspberry Pi 5: write lordos-<version>-rpi5-arm64.img.xz to an SD card or NVMe drive with Raspberry Pi Imager ("Use custom") (docs/RASPBERRY.md).
  • On an existing Debian 13 (amd64 or arm64): run curl -fsSL https://lordos.org/install.sh | sh. It asks before changing anything; --uninstall removes LordOS again (docs/INSTALL-DEBIAN.md).

Later releases: on Debian, run the installer again, or install the new .deb.

Verifying

Every release file is listed with its SHA-256 in SHA256SUMS, and SHA256SUMS.sig is the Ed25519 signature of SHA256SUMS made with the LordOS release key. The public key is lordos-release.pub.pem (in this release, in the repository at tools/release/lordos-release.pub.pem and at https://lordos.org/lordos-release.pub.pem). Its fingerprint (SHA-256 of the DER public key) is:

c7155b8e6bbbb180f907381994d06af76d333016cd6f3facf67cadd053ea108e

With OpenSSL 3, in the folder with the downloads:

openssl pkey -pubin -in lordos-release.pub.pem -outform DER | sha256sum   # must match the fingerprint
base64 -d SHA256SUMS.sig > SHA256SUMS.sig.bin
openssl pkeyutl -verify -pubin -inkey lordos-release.pub.pem -rawin -in SHA256SUMS -sigfile SHA256SUMS.sig.bin
sha256sum -c --ignore-missing SHA256SUMS

Signature Verified Successfully and OK for each file you downloaded mean the files are the ones we published. See docs/SIGNING.md.

0.7.0-beta - 2026-10-18 [YANKED]

Never published; superseded by 0.8.0-beta.