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.

The compositor at real-time priority (approved by the maintainer on 2026-10-28): lord-sessiond starts the session's lord-server with RLIMIT_RTPRIO 2 and RLIMIT_RTTIME 5 s; par_init, now called right after dropping root and before any process or thread is started, puts the main and paint threads at SCHED_RR 2 (the main thread with SCHED_RESET_ON_FORK) and lowers RLIMIT_RTPRIO to 0, soft and hard, so no app, helper or shell inherits it; the admin helper drops its own; SIGXCPU demotes, never kills. VM 116 under load: 2.65-2.92 % -> 0.28 % late frames, pointer p99 31-32 -> 25 ms; BENCHMARK, PRIVACY, ROADMAP, CHANGELOG, paper (en/es/pt), FAQ

Federico Pereira509ba91e8581
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 91b2ffc..ba70872 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -129,8 +129,21 @@ of the matching [GitHub release](https://github.com/lordbasex/LordOS/releases),
session gets the weight. Not yet measured with the Pi's monitor and GPU composition. 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 (the Pi kernel's 4 ms scheduler tick, a real-time priority for the compositor) is described there and not
- built.
+ 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. Not yet measured on the Pi 5.
- **LordBench on the Raspberry Pi 5 measured no GPU:** inside `lord-bench`'s sandbox Mesa's loader could not identify
the V3D render node ("failed to retrieve device information") and every GPU measurement was skipped. The sandbox
now also allows reading `/sys/firmware/devicetree` and `/dev/dri` (read-only; the GPU is still reached only
diff --git a/docs/BENCHMARK.md b/docs/BENCHMARK.md
index a899452..845f38f 100644
--- a/docs/BENCHMARK.md
+++ b/docs/BENCHMARK.md
@@ -377,12 +377,40 @@ compositor's threads, as lord-server would, it made no difference (8–10 % late
And turning the paint threads off when the frame waits for them under load: their own measurement showed they still
saved time, so it never acted.
-**What remains.** Under load the main thread still waits about 0.9 ms each time it wakes up: when a thread of the
-load gets a CPU it keeps it until the next scheduler tick, 4 ms on the LordOS Pi kernel (`CONFIG_HZ=250`), and the
-shared memory makes each frame about 20 % slower to build. Two further steps, not built: the Pi kernel at
-`CONFIG_HZ=1000` (`tools/rpi/build-kernel.sh`, a rebuild), and a real-time priority for the compositor's main thread
-(`SCHED_RR`, as other desktops do through rtkit) granted by lord-sessiond with a CPU-time limit, which is a new
-privilege and needs the maintainer's approval first.
+**Real-time priority (approved by the maintainer on 2026-10-28).** With the weight, the main thread under load
+still waited about 0.9 ms each time it woke up: a thread of the load that has a CPU keeps it until the next
+scheduler tick (4 ms on the LordOS Pi kernel, `CONFIG_HZ=250`). Now the compositor's main thread and its paint
+threads run at `SCHED_RR` priority 2 (the lowest real-time levels: ahead of every normal thread, behind the kernel's
+own), as KWin does for its compositor and Mutter for the thread that sends frames to the screen:
+
+- lord-sessiond starts the session's lord-server with `RLIMIT_RTPRIO` 2 and `RLIMIT_RTTIME` 5 s (soft; `remote/sess.c`).
+- lord-server takes it in `par_init` (`par.c`) right after dropping root, before it starts any process or other
+ thread: the main thread takes `SCHED_RR`, the paint threads inherit it, then the main thread adds
+ `SCHED_RESET_ON_FORK`, so every thread and process it starts later (apps, helpers, Mesa's threads, LordBench's
+ load) gets the normal policy. Then it lowers `RLIMIT_RTPRIO` to 0, soft and hard: nothing it starts can ask for
+ real time, and it can't either. The root admin helper, forked before, lowers its own to 0 too (its download child
+ drops to `nobody`).
+- A thread that runs 5 s of CPU on real time without blocking (a bug) gets `SIGXCPU`, and every thread goes back to
+ the normal policy for the rest of the session; nothing is killed. The session log says which happened
+ (`compositor at real-time priority 2 (SCHED_RR, N threads)`).
+- Without lord-sessiond, or on a kernel that refuses it (`CONFIG_RT_GROUP_SCHED`), nothing changes.
+
+Checked on VM 116 with the new lord-sessiond: the main thread is `SCHED_RR|SCHED_RESET_ON_FORK`, the 7 paint threads
+`SCHED_RR`, the other 22 threads and every child (`lord-admin`, `lord-vault`, `lord-maild`, `lord-doc`, the
+terminal's shell, `lord-bench`) `SCHED_OTHER` with a real-time limit of 0. Measured on VM 116 (8 vCPU, no monitor,
+CPU composition) under load, the session at weight 1000 laid out as lord-sessiond does, with the same limits; two
+runs each:
+
+| VM 116, under load | Build p99 | Late | Pointer to screen p50 | p99 | Load's CPU |
+|---|---|---|---|---|---|
+| Weight 1000 | 16.3–16.8 ms | 2.65–2.92 % | 14.8–15.1 ms | 31.0–32.3 ms | 91.3–91.6 s |
+| + real-time priority | 11.0–12.7 ms | 0.28 % | 13.3–14.3 ms | 24.7–25.5 ms | 90.4–91.0 s |
+
+Under load the desktop now measures as it does alone (pointer p99 about 25 ms alone), and the load got the same CPU
+time. **Not yet measured on the Pi 5** (it needs the new package installed), with or without its monitor.
+
+**What remains.** The shared memory makes each frame about 20 % slower to build under load on the Pi, which no
+priority fixes; the Pi kernel at `CONFIG_HZ=1000` (`tools/rpi/build-kernel.sh`, a rebuild) is not built.
Boot: the Pi 5 reaches the login screen on its monitor 5.99 s after the kernel starts (lord-sessiond's record;
systemd-analyze gives 2.1 s kernel + 4.2 s userspace). Boots where the monitor was connected late took 61 and
diff --git a/docs/PAPER-VALIDATION.md b/docs/PAPER-VALIDATION.md
index bcc1178..57e90e7 100644
--- a/docs/PAPER-VALIDATION.md
+++ b/docs/PAPER-VALIDATION.md
@@ -142,7 +142,7 @@ State in the 0.8.5 edition (`web/content/paper/paper.en.md`, checked 2026-10-26)
| Gap | Covers | Plan |
|---|---|---|
| A denied connection, tried on the user's machine | §6.6 effective | An app with network access and a temporary rule (Checks) |
-| Repeatable performance numbers | §7 | LordBench (0.8.6, in development: CPU, memory, GPU offscreen, storage, sustained load, software video decoding and encoders, the desktop's frame times and pointer-to-screen latency alone and under load, the boot time per version, the N-boot test and `lordos-sysreport bench` are built, with VM 116 and the Pi 5 as references, `BENCHMARK.md` "Built so far"; idle memory and CPU, hardware video decoding and app start are not) |
+| Repeatable performance numbers | §7 | LordBench (0.8.6, in development: CPU, memory, GPU offscreen, storage, sustained load, software video decoding and encoders, the desktop's frame times and pointer-to-screen latency alone and under load (and the compositor's CPU weight and real-time priority they led to), the boot time per version, the N-boot test and `lordos-sysreport bench` are built, with VM 116 and the Pi 5 as references, `BENCHMARK.md` "Built so far"; idle memory and CPU, hardware video decoding and app start are not) |
| Rendering, 3D and video on every GPU | §3.2, §7.2–7.3 | The visual test bench below |
| Every key, the mouse, touchpads, gamepads, and the Wayland protocols | §3.3–§3.4 | The visual test bench below |
| Real hardware | §10.2 | Reports from System Information (0.8.7) |
diff --git a/docs/PRIVACY.md b/docs/PRIVACY.md
index e527ea7..0c6eccc 100644
--- a/docs/PRIVACY.md
+++ b/docs/PRIVACY.md
@@ -672,7 +672,11 @@ Now the subtree stays **root-owned** and the scopes are created by root:
and moves the session's `lord-server` there, but no longer chowns anything to the user
(`cgroup_harden_session`). Since 0.8.6 (in development) it also gives `server` `cpu.weight` 1000
against 100 for every scope, so a busy app can't take half of the compositor's CPU (nice values
- don't count between cgroups; `BENCHMARK.md`, "The desktop under load"). At startup, `cgroup_service_init()` hardens the subtrees left by an
+ don't count between cgroups; `BENCHMARK.md`, "The desktop under load"). lord-sessiond also starts the
+ session's lord-server with `RLIMIT_RTPRIO` 2 (and `RLIMIT_RTTIME` 5 s): lord-server puts its main and paint threads
+ at `SCHED_RR` 2 (`SCHED_RESET_ON_FORK` on the thread that starts things) and lowers the limit to 0, soft and hard,
+ before it starts any process, so no app, helper or shell can ask for real time (`par.c`; the root admin helper,
+ forked earlier, lowers its own to 0 too). At startup, `cgroup_service_init()` hardens the subtrees left by an
older `lord-sessiond` (sessions survive a restart).
- `lord-sessiond` forks a small root child (`server/src/remote/cgsup.c`) that listens on
`/run/lordos/cgroup.sock` (`SOCK_SEQPACKET`, mode 0666; `SO_PEERCRED` decides). It serves one
diff --git a/docs/ROADMAP.md b/docs/ROADMAP.md
index 8ae96b5..6da44d7 100644
--- a/docs/ROADMAP.md
+++ b/docs/ROADMAP.md
@@ -710,7 +710,8 @@ the maintainer on 2026-10-27, item below).
encoders), the desktop-impact mode (the compositor's frame times alone and under a low-priority load), the N-boot
test, the pointer-to-screen latency, `lordos-sysreport bench` and the Pi 5 reference. Left: hardware video
decoding, the x86 PC reference, and the rest of what it found on the Pi 5 (the desktop fell to 24 fps under load;
- the compositor's CPU weight fixes most of it, `BENCHMARK.md` "The desktop under load").
+ the compositor's CPU weight and its real-time priority fix it on VM 116; the Pi measurement is pending,
+ `BENCHMARK.md` "The desktop under load").
- [ ] **Community hardware reports (0.8.7)** — `BENCHMARK.md`. Share on GitHub with the
`hardware-report` template (the user submits it, LordOS sends nothing), schema validation and
labels in a workflow, and a tested-hardware catalogue on lordos.org that the Compatibility panel
diff --git a/server/src/admin.c b/server/src/admin.c
index d0324ea..f1f0019 100644
--- a/server/src/admin.c
+++ b/server/src/admin.c
@@ -57,6 +57,7 @@
#include <sys/file.h>
#include <sys/inotify.h>
#include <sys/prctl.h>
+#include <sys/resource.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/syscall.h>
@@ -1014,6 +1015,10 @@ int admin_start(const char *user) {
int null = open("/dev/null", O_RDWR);
if (null >= 0) { dup2(null, 0); dup2(null, 1); }
syscall(SYS_close_range, 4, ~0u, 0);
+ /* the real-time limit lord-sessiond gave the compositor (par.h) is not the helper's: the
+ * processes it drops to another user (the Store's download child) must not inherit it */
+ struct rlimit rtp = { 0, 0 };
+ setrlimit(RLIMIT_RTPRIO, &rtp);
helper(3, user);
}
close(sv[1]);
diff --git a/server/src/main.c b/server/src/main.c
index 960c4fc..e9bd249 100644
--- a/server/src/main.c
+++ b/server/src/main.c
@@ -1719,6 +1719,12 @@ int main(int argc, char **argv) {
if (!freopen(log, "w", stderr)) { /* carries on without a log */ }
setvbuf(stderr, NULL, _IOLBF, 0);
}
+ /* the CPU path's pixel loops on a pool (par.h): blur, blits, gradients, the remote desktop's
+ * comparison and copies; same pixels as one thread. Its threads sleep between jobs, and jobs only
+ * run inside a frame on this thread, so the processes this server forks never inherit a busy one.
+ * Here, before this server starts any process or thread: it takes the real-time priority
+ * lord-sessiond allows and lowers that limit to 0, so nothing started later inherits it. */
+ par_init(0);
/* GPU (Mesa) after dropping root: if there is no usable one, the CPU path goes on */
/* Settings' hardware pages: displays, uevents, Bluetooth, power profiles (src/hw) */
kms_set_picker(display_pick);
@@ -1748,10 +1754,6 @@ int main(int argc, char **argv) {
static const MirrorInput mirror_in = { remote_pointer, remote_button, remote_wheel, remote_key, remote_clip, remote_clients,
remote_refresh, remote_resize, remote_greeter, display_attach, display_detach,
remote_scroll, remote_pinch, remote_input_add, remote_notice };
- /* the CPU path's pixel loops on a pool (par.h): blur, blits, gradients, the remote desktop's
- * comparison and copies; same pixels as one thread. Its threads sleep between jobs, and jobs only
- * run inside a frame on this thread, so the processes this server forks never inherit a busy one. */
- par_init(0);
if (ok && mirror_start(s.W, s.H, &mirror_in)) fprintf(stderr, "lord-server: no remote desktop (socket)\n");
char current[sizeof ui.theme_request];
if (ok) ok = start_theme(theme, s.greeter, current, sizeof current) == 0;
diff --git a/server/src/par.c b/server/src/par.c
index 2f4b74a..eadc6c5 100644
--- a/server/src/par.c
+++ b/server/src/par.c
@@ -4,9 +4,15 @@
* thread; a call made inside a piece, or from another thread while a job runs, runs serially. */
#include "par.h"
+#include <errno.h>
#include <pthread.h>
#include <sched.h>
+#include <signal.h>
#include <stdatomic.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/resource.h>
+#include <sys/syscall.h>
#include <unistd.h>
#define PAR_MAX 8
@@ -38,8 +44,11 @@ static void run_pieces(void) {
inside = 0;
}
+static atomic_int rt_tids[PAR_MAX]; /* the threads at real-time priority, for rt_demote */
+static atomic_int rt_on;
+
static void *worker(void *arg) {
- (void)arg;
+ if (atomic_load(&rt_on)) atomic_store(&rt_tids[(long)arg], (int)syscall(SYS_gettid));
unsigned long seen = 0;
for (;;) {
pthread_mutex_lock(&mu);
@@ -51,8 +60,38 @@ static void *worker(void *arg) {
return NULL;
}
+/* SIGXCPU: a thread ran PAR_RT_TIME_US on real time without blocking (a bug, or a very long theme
+ * load). Every thread goes back to the normal policy for the rest of the session; nothing is killed. */
+static void rt_demote(int sig) {
+ (void)sig;
+ struct sched_param p = { 0 };
+ for (int i = 0; i < PAR_MAX; i++) {
+ int t = atomic_load(&rt_tids[i]);
+ if (t) sched_setscheduler(t, SCHED_OTHER, &p);
+ }
+ if (atomic_exchange(&rt_on, 0)) {
+ static const char m[] = "lord-server: back to the normal priority (a thread ran too long on real time, or it could not be set)\n";
+ if (write(2, m, sizeof m - 1) < 0) {}
+ }
+}
+
+static int rt_set(int flags) {
+ struct sched_param p = { .sched_priority = PAR_RT_PRIO };
+ return sched_setscheduler(0, SCHED_RR | flags, &p);
+}
+
void par_init(int threads) {
if (nthreads > 1) return;
+ /* Real-time priority (par.h): only if lord-sessiond allowed it; the workers inherit it from this
+ * thread, which then takes SCHED_RESET_ON_FORK so nothing it starts later does */
+ struct rlimit rl;
+ if (!getrlimit(RLIMIT_RTPRIO, &rl) && rl.rlim_cur >= PAR_RT_PRIO) {
+ signal(SIGXCPU, rt_demote);
+ if (!rt_set(0)) {
+ atomic_store(&rt_tids[0], (int)syscall(SYS_gettid));
+ atomic_store(&rt_on, 1);
+ } else fprintf(stderr, "lord-server: no real-time priority (%s)\n", strerror(errno));
+ }
if (threads <= 0) {
cpu_set_t set;
threads = !sched_getaffinity(0, sizeof set, &set) ? CPU_COUNT(&set) : (int)sysconf(_SC_NPROCESSORS_ONLN);
@@ -63,13 +102,23 @@ void par_init(int threads) {
pthread_attr_t at;
pthread_attr_init(&at);
pthread_attr_setstacksize(&at, 256 * 1024);
- if (pthread_create(&t, &at, worker, NULL)) { pthread_attr_destroy(&at); break; }
+ if (pthread_create(&t, &at, worker, (void *)(long)i)) { pthread_attr_destroy(&at); break; }
pthread_attr_destroy(&at);
pthread_detach(t);
nthreads++;
}
+ if (atomic_load(&rt_on)) {
+ if (rt_set(SCHED_RESET_ON_FORK)) rt_demote(0); /* never leave a thread that forks at real time */
+ else fprintf(stderr, "lord-server: compositor at real-time priority %d (SCHED_RR, %d threads)\n", PAR_RT_PRIO, nthreads);
+ }
+ /* the limit goes to 0 for good, hard limit included: apps, helpers and shells this server starts
+ * can never ask for real time */
+ rl.rlim_cur = rl.rlim_max = 0;
+ setrlimit(RLIMIT_RTPRIO, &rl);
}
+int par_realtime(void) { return atomic_load(&rt_on); }
+
int par_threads(void) { return nthreads; }
void par_rows(int j0, int j1, ParFn fn, void *ctx) {
diff --git a/server/src/par.h b/server/src/par.h
index 947871e..59765a1 100644
--- a/server/src/par.h
+++ b/server/src/par.h
@@ -8,9 +8,20 @@
#ifndef LORD_PAR_H
#define LORD_PAR_H
+#define PAR_RT_PRIO 2 /* the lowest real-time levels: above every normal thread, below the kernel's */
+#define PAR_RT_TIME_US 5000000 /* RLIMIT_RTTIME's soft limit: 5 s of CPU without blocking */
+
typedef void (*ParFn)(void *ctx, int a, int b);
-void par_init(int threads); /* 0: the CPUs this process may use, at most 8 */
+/* 0: the CPUs this process may use, at most 8. Called once, right after dropping root and before
+ * this server starts any process or other thread: when lord-sessiond allows it (RLIMIT_RTPRIO at
+ * PAR_RT_PRIO, remote/sess.c), the calling thread and the workers take SCHED_RR at PAR_RT_PRIO, so the
+ * compositor runs ahead of any app (docs/BENCHMARK.md, "The desktop under load"); the calling thread
+ * with SCHED_RESET_ON_FORK, so threads and processes it starts later get the normal policy. Then
+ * RLIMIT_RTPRIO goes to 0 (soft and hard), always. A thread that runs PAR_RT_TIME_US without blocking
+ * gets SIGXCPU (RLIMIT_RTTIME) and every thread goes back to the normal policy. */
+void par_init(int threads);
+int par_realtime(void); /* 1 while the compositor's threads run at real-time priority */
int par_threads(void); /* threads that take pieces, the caller included (1: serial) */
void par_rows(int j0, int j1, ParFn fn, void *ctx);
diff --git a/server/src/remote/sess.c b/server/src/remote/sess.c
index 7656afc..e02787d 100644
--- a/server/src/remote/sess.c
+++ b/server/src/remote/sess.c
@@ -9,6 +9,7 @@
#include "sessiond.h"
#include "../sec/cgroup.h"
#include "rsec.h"
+#include "../par.h"
#include <crypt.h>
#include <ctype.h>
@@ -22,6 +23,7 @@
#include <stdlib.h>
#include <string.h>
#include <sys/file.h>
+#include <sys/resource.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/un.h>
@@ -327,6 +329,12 @@ static void spawn(const struct passwd *pw, const char *rt, const char *lang, int
if (sd_input_debug && !greeter) env[ne++] = "LORD_INPUT_DEBUG=1"; /* key latency trace, never the login screen */
env[ne] = NULL;
if (!greeter) cgroup_delegate_session(uid, pw->pw_gid); /* cgroup subtree for the apps (docs/SESSIONS.md) */
+ /* real-time priority for the compositor's threads: lord-server takes it in par_init and lowers
+ * the limit to 0 before it starts anything, so no app inherits it; a thread that runs 5 s
+ * without blocking gets SIGXCPU and goes back to the normal policy (par.h) */
+ struct rlimit rtp = { PAR_RT_PRIO, PAR_RT_PRIO }, rtt = { PAR_RT_TIME_US, RLIM_INFINITY };
+ setrlimit(RLIMIT_RTPRIO, &rtp);
+ setrlimit(RLIMIT_RTTIME, &rtt);
const char *const a_user[] = { rd_conf.server, "--headless", size, "--user", user, "--theme", rd_conf.theme,
"--fonts", rd_conf.fonts, "--shell", rd_conf.shell, NULL };
const char *const a_greeter[] = { rd_conf.server, "--headless", size, "--greeter", "--user", user, "--theme", rd_conf.greeter_theme,
diff --git a/web/content/faq/faq.json b/web/content/faq/faq.json
index cdc5063..21c83d8 100644
--- a/web/content/faq/faq.json
+++ b/web/content/faq/faq.json
@@ -703,9 +703,9 @@
"pt": "Posso medir quão rápido o LordOS roda no meu computador?"
},
"a": {
- "en": "Coming in 0.8.6 (in development; the latest release is 0.8.5-beta): System Information gets a Performance tab with LordBench, a quick and a full test of the processor, memory, graphics, video decoding, disk and sustained load, run in an isolated helper that stops near the temperature limit. Results are shown against reference machines measured the same way, with the conditions of each run, never as one score, and nothing is sent anywhere. A separate desktop test measures whether the desktop stays smooth, and how fast the pointer reaches the screen, while the computer is busy, and a boot test restarts it several times and keeps the median time to the login screen (a Raspberry Pi 5 with a monitor reaches it in about 6 seconds).",
- "es": "Llega en la 0.8.6 (en desarrollo; la última versión es la 0.8.5-beta): Información del sistema suma una pestaña Rendimiento con LordBench, una prueba rápida y una completa del procesador, la memoria, los gráficos, la decodificación de video, el disco y la carga sostenida, que corre en un ayudante aislado y se detiene cerca del límite de temperatura. Los resultados se muestran frente a máquinas de referencia medidas de la misma forma, con las condiciones de cada prueba, nunca como un único puntaje, y no se envía nada a ningún lado. Una prueba aparte mide si el escritorio sigue fluido, y cuánto tarda el puntero en llegar a la pantalla, mientras la computadora está ocupada, y una prueba de arranque la reinicia varias veces y se queda con la mediana del tiempo hasta la pantalla de inicio de sesión (una Raspberry Pi 5 con monitor llega en unos 6 segundos).",
- "pt": "Chega na 0.8.6 (em desenvolvimento; a última versão é a 0.8.5-beta): Informações do sistema ganha uma aba Desempenho com o LordBench, um teste rápido e um completo do processador, da memória, dos gráficos, da decodificação de vídeo, do disco e da carga contínua, executado num auxiliar isolado que para perto do limite de temperatura. Os resultados aparecem frente a máquinas de referência medidas da mesma forma, com as condições de cada teste, nunca como uma única pontuação, e nada é enviado a lugar nenhum. Um teste à parte mede se o desktop continua fluido, e quanto o ponteiro demora para chegar à tela, enquanto o computador está ocupado, e um teste de boot o reinicia várias vezes e fica com a mediana do tempo até a tela de login (um Raspberry Pi 5 com monitor chega em cerca de 6 segundos)."
+ "en": "Coming in 0.8.6 (in development; the latest release is 0.8.5-beta): System Information gets a Performance tab with LordBench, a quick and a full test of the processor, memory, graphics, video decoding, disk and sustained load, run in an isolated helper that stops near the temperature limit. Results are shown against reference machines measured the same way, with the conditions of each run, never as one score, and nothing is sent anywhere. A separate desktop test measures whether the desktop stays smooth, and how fast the pointer reaches the screen, while the computer is busy, and a boot test restarts it several times and keeps the median time to the login screen (a Raspberry Pi 5 with a monitor reaches it in about 6 seconds). What that desktop test found is already fixed in 0.8.6: the compositor gets more CPU weight than any app and the lowest real-time priority, so a busy app no longer slows the desktop down.",
+ "es": "Llega en la 0.8.6 (en desarrollo; la última versión es la 0.8.5-beta): Información del sistema suma una pestaña Rendimiento con LordBench, una prueba rápida y una completa del procesador, la memoria, los gráficos, la decodificación de video, el disco y la carga sostenida, que corre en un ayudante aislado y se detiene cerca del límite de temperatura. Los resultados se muestran frente a máquinas de referencia medidas de la misma forma, con las condiciones de cada prueba, nunca como un único puntaje, y no se envía nada a ningún lado. Una prueba aparte mide si el escritorio sigue fluido, y cuánto tarda el puntero en llegar a la pantalla, mientras la computadora está ocupada, y una prueba de arranque la reinicia varias veces y se queda con la mediana del tiempo hasta la pantalla de inicio de sesión (una Raspberry Pi 5 con monitor llega en unos 6 segundos). Lo que encontró esa prueba de escritorio ya está corregido en la 0.8.6: el compositor recibe más peso de CPU que cualquier app y la menor prioridad de tiempo real, así que una app ocupada ya no frena el escritorio.",
+ "pt": "Chega na 0.8.6 (em desenvolvimento; a última versão é a 0.8.5-beta): Informações do sistema ganha uma aba Desempenho com o LordBench, um teste rápido e um completo do processador, da memória, dos gráficos, da decodificação de vídeo, do disco e da carga contínua, executado num auxiliar isolado que para perto do limite de temperatura. Os resultados aparecem frente a máquinas de referência medidas da mesma forma, com as condições de cada teste, nunca como uma única pontuação, e nada é enviado a lugar nenhum. Um teste à parte mede se o desktop continua fluido, e quanto o ponteiro demora para chegar à tela, enquanto o computador está ocupado, e um teste de boot o reinicia várias vezes e fica com a mediana do tempo até a tela de login (um Raspberry Pi 5 com monitor chega em cerca de 6 segundos). O que esse teste de desktop encontrou já está corrigido na 0.8.6: o compositor recebe mais peso de CPU que qualquer app e a menor prioridade de tempo real, então um app ocupado não deixa mais o desktop lento."
}
}
]
diff --git a/web/content/paper/meta.json b/web/content/paper/meta.json
index 0d9d538..a525217 100644
--- a/web/content/paper/meta.json
+++ b/web/content/paper/meta.json
@@ -10,7 +10,7 @@
"pt": "Documento técnico: projeto, modelo de segurança e estado atual"
},
"version": "0.8.5 Beta",
- "date": "2026-10-27",
+ "date": "2026-10-28",
"authors": [
"Pablo Miranda",
"Federico Pereira"
diff --git a/web/content/paper/paper.en.md b/web/content/paper/paper.en.md
index 418a90e..cc74837 100644
--- a/web/content/paper/paper.en.md
+++ b/web/content/paper/paper.en.md
@@ -484,7 +484,7 @@ The Raspberry Pi 5 is the only supported board. Results on a real board (16 GB,
**Fans.** On the Pi 5 in a test case, `lord-fand` kept the fan off at 50–53 °C during a 4-thread load (the aluminium case acts as a heatsink), drove it to 55 % (4,500 RPM) and full speed (7,400 RPM) with test curves, and restored the kernel's own settings after `SIGTERM` and `kill -9` (`docs/FANS.md`).
-**Monitor and image.** Since 0.8.4.1 the Raspberry Pi 5 image shows the desktop on an HDMI monitor at the first boot (the display driver line in `config.txt` now comes after the firmware's auto-detection lines, and LordOS waits up to 30 s for the driver), sets the clock from the network, and ships Chromium and Firefox ESR. Since 0.8.4 the LordOS Pi kernel (`6.18.57-lordos.3-rpi-2712`) also destroys the connections of a blocked app. **Measured on a monitor (LordBench, 0.8.6 in development):** the 0.8.5 image booted with a 1920×1080 60 Hz monitor on either HDMI port reaches the login screen 5.99 s after the kernel starts (systemd: 2.1 s kernel, 4.2 s userspace). With GPU composition (V3D) a window moved by the compositor keeps 59.4 frames per second, with a frame built in 10.9 ms (median) and 13.0 ms (99th percentile) and 1.0 % of frames late; under an all-core load at the lowest priority it falls to 24 frames per second with 96.5 % late, a problem LordBench found: the compositor's cgroup weighed the same as the load's, so the load's low priority did not count. Giving the compositor ten times the CPU weight of an app raised the same test, run without the monitor, from 43–45 to 56–57 frames per second (31–33 % → 7–8 % late) and brought a pointer move to the screen in 22 ms instead of 32 ms (median); the measurement with the monitor is pending. In a 3-minute all-core load with the fan the board kept 5.9 GFLOP/s at 55.6 °C at most, and it decodes 1080p video in software at 258 (H.264), 246 (HEVC), 204 (VP9) and 159 (AV1) frames per second.
+**Monitor and image.** Since 0.8.4.1 the Raspberry Pi 5 image shows the desktop on an HDMI monitor at the first boot (the display driver line in `config.txt` now comes after the firmware's auto-detection lines, and LordOS waits up to 30 s for the driver), sets the clock from the network, and ships Chromium and Firefox ESR. Since 0.8.4 the LordOS Pi kernel (`6.18.57-lordos.3-rpi-2712`) also destroys the connections of a blocked app. **Measured on a monitor (LordBench, 0.8.6 in development):** the 0.8.5 image booted with a 1920×1080 60 Hz monitor on either HDMI port reaches the login screen 5.99 s after the kernel starts (systemd: 2.1 s kernel, 4.2 s userspace). With GPU composition (V3D) a window moved by the compositor keeps 59.4 frames per second, with a frame built in 10.9 ms (median) and 13.0 ms (99th percentile) and 1.0 % of frames late; under an all-core load at the lowest priority it falls to 24 frames per second with 96.5 % late, a problem LordBench found: the compositor's cgroup weighed the same as the load's, so the load's low priority did not count. Giving the compositor ten times the CPU weight of an app raised the same test, run without the monitor, from 43–45 to 56–57 frames per second (31–33 % → 7–8 % late) and brought a pointer move to the screen in 22 ms instead of 32 ms (median); the measurement with the monitor is pending. The compositor's main and paint threads now also run at the lowest real-time priority, which lord-sessiond allows and lord-server drops before it starts anything, so no app inherits it; on VM 116 under load that took late frames from 2.7–2.9 % to 0.28 % and the slowest 1 % of pointer moves from 31–32 to 25 ms, as without load, with the load getting the same CPU time (not yet measured on the Pi). In a 3-minute all-core load with the fan the board kept 5.9 GFLOP/s at 55.6 °C at most, and it decodes 1080p video in software at 258 (H.264), 246 (HEVC), 204 (VP9) and 159 (AV1) frames per second.
### 7.5 Modern PCs
diff --git a/web/content/paper/paper.es.md b/web/content/paper/paper.es.md
index 805388b..1e97837 100644
--- a/web/content/paper/paper.es.md
+++ b/web/content/paper/paper.es.md
@@ -484,7 +484,7 @@ La Raspberry Pi 5 es la única placa soportada. Resultados en una placa real (16
**Ventiladores.** En la Pi 5 dentro de un gabinete de prueba, `lord-fand` mantuvo el ventilador apagado a 50–53 °C durante una carga de 4 hilos (el gabinete de aluminio funciona como disipador), lo llevó al 55 % (4.500 RPM) y a velocidad máxima (7.400 RPM) con curvas de prueba, y restauró la configuración propia del kernel después de `SIGTERM` y de `kill -9` (`docs/FANS.md`).
-**Monitor e imagen.** Desde la 0.8.4.1 la imagen para Raspberry Pi 5 muestra el escritorio en un monitor HDMI en el primer arranque (la línea del driver de pantalla en `config.txt` ahora va después de las líneas de autodetección del firmware, y LordOS espera hasta 30 s al driver), pone la hora desde la red y trae Chromium y Firefox ESR. Desde la 0.8.4 el kernel de LordOS para la Pi (`6.18.57-lordos.3-rpi-2712`) además destruye las conexiones de una app bloqueada. **Medido con monitor (LordBench, 0.8.6 en desarrollo):** la imagen 0.8.5 arrancada con un monitor de 1920×1080 a 60 Hz en cualquiera de los dos puertos HDMI llega a la pantalla de inicio de sesión 5,99 s después de que arranca el kernel (systemd: 2,1 s de kernel y 4,2 s del resto). Con composición por GPU (V3D), una ventana movida por el compositor se mantiene en 59,4 cuadros por segundo, con un cuadro armado en 10,9 ms (mediana) y 13,0 ms (percentil 99) y el 1,0 % de cuadros tarde; con una carga en todos los núcleos a la menor prioridad baja a 24 cuadros por segundo con el 96,5 % tarde, un problema que encontró LordBench: el cgroup del compositor pesaba lo mismo que el de la carga, así que la baja prioridad de la carga no contaba. Darle al compositor diez veces el peso de CPU de una app subió la misma prueba, sin el monitor, de 43–45 a 56–57 cuadros por segundo (31–33 % → 7–8 % tarde) y llevó un movimiento del puntero a la pantalla en 22 ms en vez de 32 ms (mediana); falta la medición con el monitor. En 3 minutos de carga en todos los núcleos con el ventilador la placa mantuvo 5,9 GFLOP/s con 55,6 °C como máximo, y decodifica video 1080p por software a 258 (H.264), 246 (HEVC), 204 (VP9) y 159 (AV1) cuadros por segundo.
+**Monitor e imagen.** Desde la 0.8.4.1 la imagen para Raspberry Pi 5 muestra el escritorio en un monitor HDMI en el primer arranque (la línea del driver de pantalla en `config.txt` ahora va después de las líneas de autodetección del firmware, y LordOS espera hasta 30 s al driver), pone la hora desde la red y trae Chromium y Firefox ESR. Desde la 0.8.4 el kernel de LordOS para la Pi (`6.18.57-lordos.3-rpi-2712`) además destruye las conexiones de una app bloqueada. **Medido con monitor (LordBench, 0.8.6 en desarrollo):** la imagen 0.8.5 arrancada con un monitor de 1920×1080 a 60 Hz en cualquiera de los dos puertos HDMI llega a la pantalla de inicio de sesión 5,99 s después de que arranca el kernel (systemd: 2,1 s de kernel y 4,2 s del resto). Con composición por GPU (V3D), una ventana movida por el compositor se mantiene en 59,4 cuadros por segundo, con un cuadro armado en 10,9 ms (mediana) y 13,0 ms (percentil 99) y el 1,0 % de cuadros tarde; con una carga en todos los núcleos a la menor prioridad baja a 24 cuadros por segundo con el 96,5 % tarde, un problema que encontró LordBench: el cgroup del compositor pesaba lo mismo que el de la carga, así que la baja prioridad de la carga no contaba. Darle al compositor diez veces el peso de CPU de una app subió la misma prueba, sin el monitor, de 43–45 a 56–57 cuadros por segundo (31–33 % → 7–8 % tarde) y llevó un movimiento del puntero a la pantalla en 22 ms en vez de 32 ms (mediana); falta la medición con el monitor. Además, el hilo principal del compositor y sus hilos de pintado ahora corren con la menor prioridad de tiempo real, que lord-sessiond permite y lord-server abandona antes de lanzar nada, así que ninguna app la hereda; en la VM 116 bajo carga eso llevó los cuadros tarde de 2,7–2,9 % a 0,28 % y el 1 % más lento de los movimientos del puntero de 31–32 a 25 ms, como sin carga, con la carga recibiendo el mismo tiempo de CPU (todavía sin medir en la Pi). En 3 minutos de carga en todos los núcleos con el ventilador la placa mantuvo 5,9 GFLOP/s con 55,6 °C como máximo, y decodifica video 1080p por software a 258 (H.264), 246 (HEVC), 204 (VP9) y 159 (AV1) cuadros por segundo.
### 7.5 PC modernas
diff --git a/web/content/paper/paper.pt.md b/web/content/paper/paper.pt.md
index 9ca1dd6..f41e7fd 100644
--- a/web/content/paper/paper.pt.md
+++ b/web/content/paper/paper.pt.md
@@ -484,7 +484,7 @@ O Raspberry Pi 5 é a única placa suportada. Resultados numa placa real (16 GB,
**Ventoinhas.** No Pi 5 num gabinete de teste, o `lord-fand` manteve a ventoinha desligada a 50–53 °C durante uma carga de 4 threads (o gabinete de alumínio funciona como dissipador), a levou a 55 % (4.500 RPM) e à velocidade máxima (7.400 RPM) com curvas de teste e restaurou as configurações do próprio kernel depois de `SIGTERM` e `kill -9` (`docs/FANS.md`).
-**Monitor e imagem.** Desde a 0.8.4.1 a imagem do Raspberry Pi 5 mostra o desktop num monitor HDMI no primeiro boot (a linha do driver de vídeo no `config.txt` agora vem depois das linhas de autodetecção do firmware, e o LordOS espera até 30 s pelo driver), acerta o relógio pela rede e traz Chromium e Firefox ESR. Desde a 0.8.4 o kernel do LordOS para o Pi (`6.18.57-lordos.3-rpi-2712`) também destrói as conexões de um app bloqueado. **Medido com monitor (LordBench, 0.8.6 em desenvolvimento):** a imagem 0.8.5 inicializada com um monitor de 1920×1080 a 60 Hz em qualquer uma das duas portas HDMI chega à tela de login 5,99 s depois que o kernel inicia (systemd: 2,1 s de kernel e 4,2 s do resto). Com composição na GPU (V3D), uma janela movida pelo compositor se mantém em 59,4 quadros por segundo, com um quadro montado em 10,9 ms (mediana) e 13,0 ms (percentil 99) e 1,0 % dos quadros atrasados; com uma carga em todos os núcleos na menor prioridade cai para 24 quadros por segundo com 96,5 % atrasados, um problema que o LordBench encontrou: o cgroup do compositor pesava o mesmo que o da carga, então a baixa prioridade da carga não contava. Dar ao compositor dez vezes o peso de CPU de um app elevou o mesmo teste, sem o monitor, de 43–45 para 56–57 quadros por segundo (31–33 % → 7–8 % atrasados) e levou um movimento do ponteiro à tela em 22 ms em vez de 32 ms (mediana); falta a medição com o monitor. Em 3 minutos de carga em todos os núcleos com o ventilador a placa manteve 5,9 GFLOP/s com 55,6 °C no máximo, e decodifica vídeo 1080p por software a 258 (H.264), 246 (HEVC), 204 (VP9) e 159 (AV1) quadros por segundo.
+**Monitor e imagem.** Desde a 0.8.4.1 a imagem do Raspberry Pi 5 mostra o desktop num monitor HDMI no primeiro boot (a linha do driver de vídeo no `config.txt` agora vem depois das linhas de autodetecção do firmware, e o LordOS espera até 30 s pelo driver), acerta o relógio pela rede e traz Chromium e Firefox ESR. Desde a 0.8.4 o kernel do LordOS para o Pi (`6.18.57-lordos.3-rpi-2712`) também destrói as conexões de um app bloqueado. **Medido com monitor (LordBench, 0.8.6 em desenvolvimento):** a imagem 0.8.5 inicializada com um monitor de 1920×1080 a 60 Hz em qualquer uma das duas portas HDMI chega à tela de login 5,99 s depois que o kernel inicia (systemd: 2,1 s de kernel e 4,2 s do resto). Com composição na GPU (V3D), uma janela movida pelo compositor se mantém em 59,4 quadros por segundo, com um quadro montado em 10,9 ms (mediana) e 13,0 ms (percentil 99) e 1,0 % dos quadros atrasados; com uma carga em todos os núcleos na menor prioridade cai para 24 quadros por segundo com 96,5 % atrasados, um problema que o LordBench encontrou: o cgroup do compositor pesava o mesmo que o da carga, então a baixa prioridade da carga não contava. Dar ao compositor dez vezes o peso de CPU de um app elevou o mesmo teste, sem o monitor, de 43–45 para 56–57 quadros por segundo (31–33 % → 7–8 % atrasados) e levou um movimento do ponteiro à tela em 22 ms em vez de 32 ms (mediana); falta a medição com o monitor. Além disso, a thread principal do compositor e suas threads de pintura agora rodam com a menor prioridade de tempo real, que o lord-sessiond permite e o lord-server abandona antes de iniciar qualquer coisa, então nenhum app a herda; na VM 116 sob carga isso levou os quadros atrasados de 2,7–2,9 % para 0,28 % e o 1 % mais lento dos movimentos do ponteiro de 31–32 para 25 ms, como sem carga, com a carga recebendo o mesmo tempo de CPU (ainda não medido no Pi). Em 3 minutos de carga em todos os núcleos com o ventilador a placa manteve 5,9 GFLOP/s com 55,6 °C no máximo, e decodifica vídeo 1080p por software a 258 (H.264), 246 (HEVC), 204 (VP9) e 159 (AV1) quadros por segundo.
### 7.5 PCs modernos