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.

Website content: six feature deep-dives, project paper (EN/ES/PT), legal pages, FAQ, footer; wording: built on Debian and Wayland

Federico Pereira8d7eb98aedbd
diff --git a/README.md b/README.md
index 43bd5c2..d8dc8d0 100644
--- a/README.md
+++ b/README.md
@@ -7,11 +7,11 @@
# LordOS
-**A free, fast and secure GNU/Linux desktop, built from scratch.**
+**A free, fast and secure GNU/Linux desktop, built on solid Debian and Wayland foundations.**
LordOS is a free GNU/Linux distribution based on Debian 13. It ships its own desktop
-environment instead of GNOME or KDE, and it doesn't use X11: a display server and Wayland
-compositor written in C, its own React-based UI engine, and native apps designed to feel calm,
+environment instead of GNOME or KDE, built from its fundamental components on top of Debian and
+Wayland, and it doesn't use X11: a display server and Wayland compositor written in C, its own React-based UI engine, and native apps designed to feel calm,
clear and private. An idle session uses about 120 MB of RAM. Its look and workflow take inspiration from the desktop of a well-known
fruit-logo company: a Dock, an app launcher, a menu bar, instant search and polished native
apps, all reimagined as free software. It runs on Intel/AMD PCs and on the Raspberry Pi 5, and
diff --git a/assets/locales/en/about.json b/assets/locales/en/about.json
index bc2b6f4..7352ac8 100644
--- a/assets/locales/en/about.json
+++ b/assets/locales/en/about.json
@@ -26,7 +26,7 @@
"other": "{ms} ms · {count} nodes"
},
"server": "Display server",
- "tagline": "A free, fast and secure GNU/Linux desktop, built from scratch.",
+ "tagline": "A free, fast and secure GNU/Linux desktop, built on Debian and Wayland.",
"uptime": "Uptime",
"version": "Version {v}",
"versionChannel": "Version {v} · {channel}"
diff --git a/assets/locales/es/about.json b/assets/locales/es/about.json
index 35cedae..73a4112 100644
--- a/assets/locales/es/about.json
+++ b/assets/locales/es/about.json
@@ -26,7 +26,7 @@
"other": "{ms} ms · {count} nodos"
},
"server": "Servidor gráfico",
- "tagline": "Un escritorio GNU/Linux libre, rápido y seguro, hecho desde cero.",
+ "tagline": "Un escritorio GNU/Linux libre, rápido y seguro, construido sobre Debian y Wayland.",
"uptime": "Encendido hace",
"version": "Versión {v}",
"versionChannel": "Versión {v} · {channel}"
diff --git a/assets/locales/pt/about.json b/assets/locales/pt/about.json
index 80bb6e3..33fc9c8 100644
--- a/assets/locales/pt/about.json
+++ b/assets/locales/pt/about.json
@@ -26,7 +26,7 @@
"other": "{ms} ms · {count} nós"
},
"server": "Servidor gráfico",
- "tagline": "Um desktop GNU/Linux livre, rápido e seguro, feito do zero.",
+ "tagline": "Um desktop GNU/Linux livre, rápido e seguro, construído sobre Debian e Wayland.",
"uptime": "Ligado há",
"version": "Versão {v}",
"versionChannel": "Versão {v} · {channel}"
diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md
index f33bc42..fcd42fa 100644
--- a/docs/ARCHITECTURE.md
+++ b/docs/ARCHITECTURE.md
@@ -2,7 +2,7 @@
LordOS is a **GNU/Linux distribution based on Debian 13** that ships a **desktop environment of
its own** (on the level of KDE or GNOME) with a **real display server and Wayland compositor
-written from scratch in C**. It is not a simulator or a web page: it takes the
+written in C**, built from its fundamental components on top of Debian and Wayland. It is not a simulator or a web page: it takes the
graphics card and input directly from the Linux kernel. The interface (desktop, bar, dock,
native apps) is written in **JavaScript with React**, which draws on an engine of our own, just
like React Native but on top of our display server.
diff --git a/docs/LORDOS-BRAND.md b/docs/LORDOS-BRAND.md
index 394c6ca..16c19ee 100644
--- a/docs/LORDOS-BRAND.md
+++ b/docs/LORDOS-BRAND.md
@@ -14,8 +14,8 @@ the renders by hand.
## 1. What LordOS is
-LordOS is a free, fast and secure GNU/Linux distribution based on Debian, with a desktop built from
-scratch. Its desktop environment has its own display server and Wayland compositor written in C and
+LordOS is a free, fast and secure GNU/Linux distribution based on Debian, with a desktop environment of
+its own, built from its fundamental components on top of Debian and Wayland. It has its own display server and Wayland compositor written in C and
its own React-based interface engine, an idle session uses
about 120 MB of RAM, and it brings a Dock, an app launcher, a menu bar, instant search and polished
native apps to PCs and to the Raspberry Pi 5, while still running regular Linux applications. The
diff --git a/docs/PAPER.md b/docs/PAPER.md
new file mode 100644
index 0000000..7860710
--- /dev/null
+++ b/docs/PAPER.md
@@ -0,0 +1,671 @@
+# LordOS: a private, fast GNU/Linux desktop built on Debian and Wayland
+
+*Technical whitepaper: design, security model and current state*
+
+Version 0.7.0 Beta · 2026-10-18 · Pablo Miranda, Federico Pereira (IPERFEX)
+
+> This is the English copy of the paper published on lordos.org, where the figures are drawn as
+> diagrams. Source: `web/content/paper/paper.en.md` and `web/content/paper/diagrams.json`.
+
+## Abstract
+
+LordOS is a free GNU/Linux distribution based on Debian 13 that ships a desktop environment of its own, built from its fundamental components on top of Debian and Wayland. Instead of GNOME or KDE, it has its own display server and Wayland compositor written in C (`lord-server`), its own user-interface engine (React running on the QuickJS JavaScript engine, with layout, painting and text in native C code), its own native apps, and its own security services: an app sandbox launcher, a permission broker, a per-app permission store, a kernel-enforced per-app firewall, package signing and an encrypted password vault. It reuses what is mature and widely reviewed: the Linux kernel, Debian and its packages, Mesa, PipeWire, the Wayland protocol, and a handful of libraries (FFmpeg, Poppler, libarchive, OpenSSL, Monocypher) that are confined to small sandboxed helper processes.
+
+This paper describes the design and the current state of version **0.7.0 Beta** (October 2026) for a technical reader who wants to check the project rather than take it on trust. Every claim refers to a file in the public repository. Numbers are the ones measured in the project's test logs, and are labelled with where they were measured. Things that are designed but not built are marked as such.
+
+## 1. Vision
+
+### 1.1 The problem
+
+A modern Linux desktop is assembled from many independent projects: a display server or compositor, a toolkit, a session manager, a settings daemon, a keyring, a network manager, a firewall front end, and the apps. Each is good on its own terms, but the seams between them are where things get slow, inconsistent or insecure. Three seams in particular motivated LordOS:
+
+- **Weight.** A desktop that draws its shell with a web engine, or loads several toolkits at once, needs hundreds of megabytes before the user opens anything. LordOS wants to be comfortable on modest machines and on a Raspberry Pi 5.
+- **Trust in apps.** On a traditional Linux desktop, every program the user runs can read the whole home folder, record the microphone, open any network connection and read the clipboard. Sandboxing exists, but it is usually an add-on that the desktop itself doesn't understand.
+- **Visibility.** Users rarely see which app is talking to which server, and even more rarely can they say "this app may not use the internet" in a way the app can't get around.
+
+### 1.2 Principles
+
+The project follows a short list of rules, written down in `AGENTS.md` and `docs/ARCHITECTURE.md`:
+
+1. **Own the parts the user touches; reuse the foundations.** The display server, the compositor, the UI engine, the apps and the security services are LordOS's code. The kernel, Debian's packages, Mesa, PipeWire and the Wayland protocol are reused.
+2. **A strict dependency policy.** X11, wlroots, libdrm, libinput, WebKit, GTK and Qt are not used inside LordOS. Libraries that parse untrusted data are linked only by sandboxed helpers, never by the compositor.
+3. **The interface can't run commands.** JavaScript in LordOS has no API to execute arbitrary programs. There are three narrow, argument-free exceptions (the Terminal's login shell, launching an installed `.desktop` app, and starting an installed `.lpk` app in its sandbox).
+4. **Root only through closed doors.** Everything that needs root goes through a fixed table of validated actions or a small dedicated service with a closed protocol.
+5. **The CPU path must always work.** GPU composition is an optimization, never a requirement.
+6. **The compositor never waits.** Helpers, apps and services talk to `lord-server` over non-blocking sockets; a hung app hangs only itself.
+7. **Verify on a real system.** Every milestone is checked on a virtual machine with real screenshots before it is marked done, and compatibility that wasn't tested isn't claimed.
+
+### Source files
+
+- [AGENTS.md](https://github.com/lordbasex/LordOS/blob/main/AGENTS.md)
+- [docs/ARCHITECTURE.md](https://github.com/lordbasex/LordOS/blob/main/docs/ARCHITECTURE.md)
+
+## 2. Architecture
+
+### 2.1 Layers
+
+**Figure: The layers of LordOS.**
+
+```
+Apps
+ Built-in apps and the theme · isolated .lpk apps · Linux apps (GTK, Qt, browsers)
+ │
+LordOS UI engine
+ React on QuickJS, native layout, painting and text in C. Used by LordOS's own apps; Linux apps don't go through it
+ │
+LordOS display server and Wayland compositor
+ lord-server, in C: KMS without libdrm, evdev without libinput, composition on CPU or GPU. Linux apps and isolated .lpk apps connect here as Wayland clients
+ │
+Debian 13 userland
+ dpkg and packages, Mesa (optional GPU), PipeWire, libwayland, libxkbcommon, systemd
+ │
+Linux kernel
+ DRM/KMS, evdev, Landlock, seccomp, cgroups v2, eBPF
+```
+
+*Violet layers are LordOS's own code; the lower layers are reused from Debian and Linux.*
+
+From the bottom up:
+
+- **The Linux kernel** provides DRM/KMS for displays, evdev for input, and the security features LordOS builds on: Landlock, seccomp-bpf, cgroups v2 and eBPF. On PCs it is Debian's kernel; on the Raspberry Pi 5 it is LordOS's build of the Raspberry Pi kernel with Landlock enabled (§7.4).
+- **Debian 13** provides the userland: `dpkg` and the package archive, systemd, Mesa, PipeWire, `libwayland`, `libxkbcommon`, CUPS, BlueZ and the rest.
+- **`lord-server`** is the display server and Wayland compositor. It drives displays and input directly, composites, and serves the Wayland protocol to Linux apps.
+- **The UI engine** lives inside `lord-server`: QuickJS runs the React interface, and native C code does layout, painting and text.
+- **Apps** come in three kinds: built-in apps and the theme, which run in `lord-server`'s JavaScript context; installed `.lpk` apps, each in its own sandboxed process with its own engine instance; and Linux apps, which connect to the compositor as ordinary Wayland clients.
+
+### 2.2 Processes and privileges
+
+**Figure: Processes and privileges.**
+
+```
+Sandboxed app processes
+ lord-server --app <id>: one per .lpk app and Passwords; Landlock, seccomp, cgroup
+ │
+Sandboxed helpers
+ lord-doc, lord-media, lord-maild, lord-vault: no sockets, no exec, files only as descriptors
+ │
+lord-server (one per user)
+ Runs as the user: compositor, UI engine, broker; no command execution
+ │
+Root services with closed interfaces
+ lord-sessiond, lord-netd, lord-netperm, lord-fand, and the admin helper's fixed action table
+ │
+Linux kernel
+ Enforces Landlock, seccomp, cgroups and the firewall's eBPF programs
+```
+
+*Privilege goes down the stack; each layer talks to the one below only through a narrow, validated interface.*
+
+A running LordOS system has a small number of processes with clearly separated roles:
+
+| Process | Runs as | Role |
+|---|---|---|
+| `lord-sessiond` | root | login screen, sessions, lending the display and input to the visible session, remote desktop |
+| `lord-netd` | root | the system network: DHCP, Wi-Fi, VPN; only the `net-*` actions |
+| `lord-netperm` | root (limited capabilities) | per-app network rules, enforced with cgroup eBPF |
+| `lord-fand` | root (no capabilities) | fan control by temperature |
+| `lord-server` | the user | one per session: compositor, UI engine, broker |
+| `lord-server --app <id>` | the user, sandboxed | one per running `.lpk` app (and Passwords) |
+| `lord-doc`, `lord-media`, `lord-maild`, `lord-vault` | the user, sandboxed | helpers that process untrusted data or secrets |
+| login screen | `lordos-greeter` | draws the login UI; never verifies passwords itself |
+
+Each root process has a narrow, documented interface. §6.3 describes them.
+
+### 2.3 What is ours and what is reused
+
+| Ours (in this repository) | Reused |
+|---|---|
+| Display server and Wayland compositor (C) | Linux kernel |
+| UI engine: native nodes, flexbox layout, rasterizer, text shaping, bidi, input methods | Debian 13 and its packages; `dpkg` |
+| React renderer (host configuration for `react-reconciler`) | React 19.3.1, `react-reconciler` 0.34 (bundled in the theme) |
+| Native apps and themes | QuickJS 2025-04-26 (vendored) |
+| Sandbox, broker, permissions, signing, firewall service, vault | Mesa (optional), PipeWire, `libwayland`, `libxkbcommon` |
+| Session manager, network service, fan service | systemd, systemd-resolved, BlueZ, CUPS, wpa_supplicant, OpenVPN, strongSwan's daemon |
+| Debian package engine (OpenPGP, xz, HTTP, resolver) | FFmpeg, Poppler, libarchive, OpenSSL, Monocypher (in helpers only) |
+| Touchpad driver, terminal emulator, WebAssembly interpreter | stb (fonts and images), fonts under the OFL |
+
+LordOS speaks to several Debian services over their own protocols with its own clients: D-Bus (BlueZ, power profiles, time and date), IPP (CUPS), the PulseAudio protocol (PipeWire), and the Secret Service. libdbus, sd-bus, libcups, libpulse, libbpf and libapt are not used.
+
+### 2.4 System services
+
+- **Network (`lord-netd`).** The network belongs to the system, not to a session. `lord-sessiond` starts `lord-netd` at boot with a fixed path and no arguments, so the machine has an address before anyone logs in. It runs only the closed `net-*` actions: its own DHCP client and netlink code, Wi-Fi through Debian's `wpa_supplicant`, WireGuard through LordOS's own netlink code, OpenVPN, IPsec/IKEv2 through strongSwan's `charon` driven over VICI with LordOS's own client, and optionally OpenConnect, PPTP and Fortinet-compatible tunnels. It talks only to the sessions' root helpers, over a socket that accepts only uid 0.
+- **Fans (`lord-fand`).** A root service that reads the CPU temperature every 2 s and writes fan duty from a profile, from early boot. It drives only fans its own scan found: the Raspberry Pi 5 fan header and allow-listed motherboard controllers. Laptop, GPU and unknown fans are never written. On stop, or after a crash, it restores the original kernel settings. It runs no programs, has no network, no capabilities and no device nodes.
+- **Hardware settings.** Displays (modes from KMS with EDID names, a 15-second "keep these settings?" revert, per-display persistence, rotation, Night Light), Bluetooth through BlueZ, battery and power profiles, idle and lid handling, date and time, notifications for Linux apps and default apps. Changes arrive as kernel uevents and D-Bus signals; nothing polls.
+
+### Source files
+
+- [server/src/main.c](https://github.com/lordbasex/LordOS/blob/main/server/src/main.c)
+- [server/src/admin.c](https://github.com/lordbasex/LordOS/blob/main/server/src/admin.c)
+- [server/src/net/netd.c](https://github.com/lordbasex/LordOS/blob/main/server/src/net/netd.c)
+- [server/src/fan/fand.c](https://github.com/lordbasex/LordOS/blob/main/server/src/fan/fand.c)
+- [server/src/hw](https://github.com/lordbasex/LordOS/tree/main/server/src/hw)
+
+## 3. The compositor
+
+### 3.1 Displays without libdrm
+
+`lord-server` sets display modes with the kernel's DRM ioctls directly (`kms.c`): it enumerates connectors, CRTCs and planes, allocates buffers, and page-flips on vertical blank. It picks the card that has connectors, not simply `card0`, which matters on boards where the display controller and the GPU are separate devices (on the Raspberry Pi 5, `vc4` and `v3d`).
+
+### 3.2 Two ways to build a frame
+
+- **CPU path.** The UI and app windows are copied into a canvas, and a "dumb" buffer is presented with a page flip. It needs nothing but the kernel. It is the default when there is no 3D-capable card, and `LORD_GPU=0` forces it (the boot menu's safe mode uses it).
+- **GPU path.** Mesa's GBM, EGL and GLES2 (`server/src/gpu/gpu.c`). The UI becomes one texture, and only the changed region is uploaded each frame. App windows are not copied into the UI canvas: the UI leaves a transparent hole where each window goes, and window textures are drawn underneath, so an app that only changes its own content doesn't cause a UI repaint. Apps can hand over GPU buffers (`linux-dmabuf`) with no copies, and a fullscreen app with a suitable buffer is scanned out directly. The cursor uses the hardware cursor plane.
+
+The path is chosen at start-up: a card without 3D (simpledrm, bochs, virtio-gpu without virgl, and others) uses the CPU without even loading Mesa; a software OpenGL renderer also falls back to the CPU, because composing with it costs more than LordOS's own CPU path. If a GPU frame fails, the GPU is turned off and the CPU path takes over.
+
+**Status:** the GPU path was exercised with Mesa's software renderer in virtual machines. Testing on real AMD and Nvidia cards is pending.
+
+### 3.3 Windows and input
+
+- **Window management in C.** Moving and resizing run in C with one event per frame and no JavaScript, and a window being moved is drawn from its own layer. All four edges and corners resize, with LordOS's own cursors.
+- **Input without libinput.** Keyboards, mice and tablets are read from evdev. Keyboard layouts come from `libxkbcommon` (every XKB layout, variants and compose).
+- **Touchpad and touchscreen.** LordOS has its own multitouch driver (`server/src/tp`): pointer acceleration, tap and two-finger click, palm rejection, kinetic and natural scrolling, pinch, and three-finger swipes. Gestures reach both the LordOS interface and Linux apps (`zwp_pointer_gestures_v1`). It is tested with recorded gestures in `make test`.
+
+### 3.4 Wayland compatibility
+
+The compositor (`server/src/wl/wl.c`) uses only `libwayland-server` and code generated from the protocol XML. It offers: `wl_compositor`, `wl_subcompositor`, `wl_shm`, `wl_output` (one per display), `xdg_wm_base` with popups, `wl_seat` (pointer, keyboard, touch), `wl_data_device_manager` (a clipboard shared with LordOS), `zxdg_decoration_manager_v1`, the KDE server-decoration protocol (so GTK 3 apps such as Firefox get the theme's frame), `zxdg_output_manager_v1`, `wp_fractional_scale_v1`, `wp_viewporter`, `zwp_linux_dmabuf_v1` v4, `wp_presentation`, `zwp_relative_pointer_manager_v1`, `zwp_pointer_constraints_v1`, `zwp_pointer_gestures_v1` and `wp_cursor_shape_manager_v1`.
+
+Linux windows enter the SDK's window manager like any other, with title, focus, maximize, minimize and a Dock icon. Apps that ask for server-side decoration get the theme's frame; apps that draw their own (GTK 4) keep it, and their shadow is clipped. GTK 4 and libadwaita apps follow light/dark mode, the accent and the button order through an `org.freedesktop.portal.Settings` implementation that `lord-server` serves itself on the session bus; GTK 3 follows through the GSettings keyfile.
+
+**Xwayland is not supported**: LordOS doesn't run X11-only apps. Also pending: drag and drop, the primary selection, LordOS input methods inside Linux apps (`text-input`), activation (`xdg-activation`), explicit sync and SVG app icons. No screen-capture protocol is offered to apps.
+
+### 3.5 Several displays and HiDPI
+
+Every connected display is driven at once, extended or mirrored, in one logical space, with an arrangement remembered by EDID identity and hotplug handling. Each display is painted at its own scale (100, 125, 150, 175 or 200 %), so text and vectors are rasterized at its real resolution. Linux apps get one `wl_output` per display and fractional scaling. Tested with two virtual heads (1280×800 and 2560×1600) on both paths; real monitors, laptop panels and DisplayPort hubs are untested.
+
+### 3.6 Sessions and login
+
+**Figure: Lending the display to a session.**
+
+```
+[Login screen] Runs as lordos-greeter; only sends the request
+ │ login request
+ ▼
+[lord-sessiond (root)] Verifies the password against /etc/shadow
+ │ opens
+ ▼
+[Card and input] Opened as root, passed over a socket
+ │ lent
+ ▼
+[User session] lord-server as the user, composing on GPU or CPU
+ │ on a switch
+ ▼
+[Switch user] Input revoked, display control dropped, then lent to the next
+```
+
+*The visible session uses the GPU without ever being root; on a switch its access is revoked before the next session gets the devices.*
+
+`lord-sessiond` is LordOS's own session manager:
+
+- **The login screen** is a `lord-server` running as the unprivileged `lordos-greeter` user, with a special theme. It sends login requests to `lord-sessiond`; **passwords are always verified by the root process** against `/etc/shadow`, never by the greeter's JavaScript. Failed attempts wait 1, 2, 4… seconds, up to 5 minutes.
+- **One session per user**, all able to live at once (fast user switching). Each is a `lord-server` that starts as root and drops privileges right away.
+- **Display lending.** `lord-sessiond` opens the graphics card and the input devices as root and lends them to the session that is on the monitor, over a Unix socket. On a switch it revokes them: `EVIOCREVOKE` makes the old session's input file descriptors stop working, and `DROP_MASTER` takes display control away, before anything is given to the next session. The visible session keeps composing on the GPU without ever being root. A session off the monitor draws in memory, and only if someone is watching it remotely.
+- **Locking really takes the session off the monitor**; it is not a layer drawn on top. If the user's session hangs, the login screen still works.
+
+**Remote desktop.** The same service offers the desktop to a browser on the local network at `https://<address>:5673` (5673 spells "LORD" on a phone keypad). It is **off by default** and is turned on in Settings → Sharing. It uses TLS 1.2 or later with a self-signed P-256 certificate whose fingerprint Settings shows for comparison, a strict content security policy, same-origin checks, per-IP waits on failed logins, and a session cookie that is `Secure`, `HttpOnly` and `SameSite=Strict`. The login page never lists user accounts. The process that serves a connection drops root as soon as it knows whose session it is. Screen updates are sent as PNG when still and JPEG while moving. Audio is designed but not built. Internet access is not intended; a VPN is recommended.
+
+### Source files
+
+- [server/src/kms.c](https://github.com/lordbasex/LordOS/blob/main/server/src/kms.c), [server/src/gpu/gpu.c](https://github.com/lordbasex/LordOS/blob/main/server/src/gpu/gpu.c), [server/src/outputs.c](https://github.com/lordbasex/LordOS/blob/main/server/src/outputs.c)
+- [server/src/input.c](https://github.com/lordbasex/LordOS/blob/main/server/src/input.c), [server/src/tp](https://github.com/lordbasex/LordOS/tree/main/server/src/tp), [server/src/ui/grab.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/grab.c)
+- [server/src/wl/wl.c](https://github.com/lordbasex/LordOS/blob/main/server/src/wl/wl.c), [server/src/ui/portal.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/portal.c)
+- [server/src/remote/sessiond.c](https://github.com/lordbasex/LordOS/blob/main/server/src/remote/sessiond.c), [server/src/remote/monitor.c](https://github.com/lordbasex/LordOS/blob/main/server/src/remote/monitor.c), [server/src/remote/sess.c](https://github.com/lordbasex/LordOS/blob/main/server/src/remote/sess.c)
+
+## 4. The UI engine
+
+### 4.1 Not a browser
+
+LordOS's interface is written in JavaScript with React, but there is no web engine underneath. WebKit or Chromium would cost 100 to 300 MB of RAM per process and would not be LordOS's code. Instead, the theme and the apps use a React renderer (`runtime/index.js`) that creates and updates **native nodes** in C: `View`, `Text`, `Image`, plus surfaces for Wayland windows and media. Styles are a subset of CSS (flexbox, colours, rounded and per-side borders, shadows, blur, transforms, transitions) applied by C code that the project controls. The model is close to how a mobile framework renders React to native views, except that the "native" side here is LordOS's own.
+
+### 4.2 Pieces
+
+- **JavaScript:** QuickJS 2025-04-26, a small ES2023 engine in C, vendored as source and embedded in `lord-server`.
+- **React:** React 19.3.1 with `react-reconciler` 0.34, bundled with esbuild into each theme. The default theme with every app weighs 367 KB.
+- **Layout:** LordOS's own flexbox implementation (`layout.c`), with wrapping, logical start/end edges and right-to-left mirroring.
+- **Painting:** LordOS's own 2D rasterizer with antialiased rounded rectangles, cached shadows, reduced-resolution blur and damage tracking: only the changed region is repainted. On ARM, optional NEON loops speed up blits and masks, verified bit-identical to the C code.
+- **Text:** glyphs are rasterized with `stb_truetype`. Shaping is LordOS's own OpenType code (GSUB substitutions and GPOS positioning, colour emoji), with full Unicode bidi, Arabic joining, Indic shaping and the Universal Shaping Engine (409 of 409 test sentences identical to HarfBuzz in `tests/hb_compare.py`), CJK line breaking, Thai word breaking, and per-script font fallback. HarfBuzz, FreeType, fontconfig, fribidi and ICU are not linked by `lord-server`.
+- **Input methods:** Korean (hangul), Japanese (kana and SKK) and Chinese (pinyin), in `server/src/ime.c`, with no ibus or fcitx.
+
+**Figure: From a mouse move to a new frame.**
+
+```
+[evdev event] From the kernel
+ │ read
+ ▼
+[Hit test] Which node is under the pointer
+ │ JS event
+ ▼
+[React update] Only changed nodes are marked
+ │ styles, children, text
+ ▼
+[Layout and paint] Only the damaged region
+ │ back buffer
+ ▼
+[Page flip] On the next vblank, CPU or GPU path
+```
+
+*The engine repaints only what changed, then flips the page on the next vertical blank.*
+
+### 4.3 How JavaScript reaches the system
+
+The JavaScript side calls native services through `lord.*` APIs implemented in C (`server/src/ui/js_*.c`): `lord.fs` (files), `lord.settings`, `lord.net`, `lord.pkg`, `lord.media`, `lord.mail`, `lord.vault`, `lord.fw`, `lord.monitor`, `lord.fan` and others. Every call validates its arguments in C. The rules are strict:
+
+- `lord-server` runs without root, and **no API executes arbitrary commands**.
+- `lord.fs` writes only in the home folder and the user's own mounts, has no general "delete" (only moving to the Trash), and refuses the folders the system reads to launch or install something or that store security decisions: `~/.local/share/applications`, `~/.config/autostart`, the installed app folder, `settings.json`, the permissions file, the firewall rules, the mail accounts file and the vault folder.
+- Anything that needs root goes through `admin.c`: a closed table of actions with arguments validated on the root side, fixed program paths and configuration generated by LordOS, never user text passed to a shell. Passwords go through standard input, never on a command line.
+- Long work never blocks a frame: helpers and services are polled from the main loop without waiting.
+
+### 4.4 Languages
+
+The interface ships in English (the default), Spanish and Portuguese, and more languages are added as language packs without code changes. Text goes through the SDK's `t('namespace.key')`, with plurals and locale formats. The whole interface mirrors for right-to-left languages, and the region (`LANG`/`LC_*`) is passed to Linux apps. `node tools/i18n-check.mjs` checks that every key exists in every language and that no third-party brand names appear in the interface.
+
+### Source files
+
+- [runtime/index.js](https://github.com/lordbasex/LordOS/blob/main/runtime/index.js), [sdk/index.js](https://github.com/lordbasex/LordOS/blob/main/sdk/index.js)
+- [server/src/ui/js.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/js.c), [server/src/ui/node.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/node.c), [server/src/ui/layout.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/layout.c), [server/src/ui/paint.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/paint.c)
+- [server/src/ui/shape.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/shape.c), [server/src/ui/otf.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/otf.c), [server/src/ui/bidi.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/bidi.c), [server/src/ime.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ime.c)
+- [server/src/ui/js_sys.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/js_sys.c), [server/src/fsops.c](https://github.com/lordbasex/LordOS/blob/main/server/src/fsops.c)
+
+## 5. Applications
+
+### 5.1 Native apps
+
+Around thirty native apps ship with LordOS, all React apps on the same engine and SDK: Files, Settings, Terminal, Store, Text Editor, Notes, Calculator, Monitor, PDF Viewer, Fonts, Emoji & Symbols, Scanner, Photos, Player, Screenshots, Camera, Recorder, Passwords, Disks, Backups, Logs, Clock, Help, Mail, Calendar, Contacts, Reminders, About and the installer. Some highlights:
+
+- **Terminal:** LordOS's own xterm-compatible emulator in C, with tabs, split panes, profiles, inline images and Sixel, and sessions that survive a restart of `lord-server`.
+- **Monitor:** CPU, memory, disks, processes, cooling and per-app network connections on a world map, with country lookup from a local database. Its sampling thread exists only while the app is open.
+- **Disks:** LordOS's own SMART reader, formatting, and bootable USB sticks verified with SHA-256.
+- **Backups:** hard-link snapshots with optional encryption, running at low priority.
+
+### 5.2 Installable `.lpk` apps
+
+Third-party native apps are packaged as `.lpk`: a gzip-compressed tar with a manifest, the bundled `app.js`, a required icon, optional translations and assets. An app doesn't carry React or the SDK; it uses the system's, which keeps it small (the example Fractal app weighs 5 KB). They install without root into `~/.local/share/lordos/apps/<id>/`. The installer rejects links, devices, absolute paths, `..`, odd characters, more than 2,000 files or 64 MB, and replaces the previous version atomically. Each one runs isolated (§6.4).
+
+### 5.3 The Store and Debian packages
+
+The Store shows Debian's apps by category with search, `.lpk` apps and local `.deb` files, and always shows a plan before installing or removing. Debian packages are handled by **LordOS's own package engine** (`server/src/pkg`): it reads the apt sources, verifies `InRelease` signatures with its own OpenPGP code (RSA and Ed25519), refuses expired, replayed, wrong-suite or trailing-data indexes, checks every index and `.deb` against SHA-256 values from the signed index, and resolves dependencies (plans identical to apt's in 12 test cases). Only the last step is Debian's: `dpkg` unpacks and configures, and remains the only writer of its database, so `apt` keeps working. LordOS has no TLS client of its own, so `https://` sources are fetched over `http://`; integrity rests on the signatures and hashes, but the package names downloaded are visible on the network.
+
+### 5.4 Linux apps
+
+Linux apps with a `.desktop` file appear in the app launcher. Launching goes through `lord.apps.launch(id)`: the interface can only name an installed `.desktop` file; `lord-server` re-reads it, checks it, builds `argv` from its `Exec` line by the specification and runs it with `execve`, without a shell or caller arguments, inside its own root-owned cgroup scope. Chromium and Firefox are preinstalled in the ISO and were verified with the LordOS frame. **Linux apps are not sandboxed by LordOS**; they get attribution and the per-app firewall (§6.6).
+
+### 5.5 WebAssembly
+
+LordOS includes its own WebAssembly interpreter in C (`server/src/wasm`), exposed as the standard `WebAssembly` global, so a native app can carry modules compiled from C, C++, Rust or Zig. It covers WebAssembly 2.0 without SIMD (the MVP plus sign extension, saturating conversions, multi-value, bulk memory and reference types), passes 26,290 of 26,290 assertions of the official test suite on the VM, and turns every error into a trap rather than a crash. On the project's example it ran 3 to 5 times faster than the same code in JavaScript.
+
+### 5.6 Installing LordOS
+
+- **Live ISO** for 64-bit PCs, with a graphical installer (UEFI and BIOS).
+- **Raspberry Pi 5 image** for SD card or NVMe (§7.4).
+- **On an existing Debian 13**: `curl -fsSL https://lordos.org/install.sh | sh`. The script asks before changing anything, downloads `SHA256SUMS` and verifies its Ed25519 signature with the release key embedded in the script, refuses to continue without a valid signature, checks the `.deb`'s SHA-256, installs it with apt and sets the system up like the ISO. The repository is private until the first public beta, so the download path is not public yet.
+
+### Source files
+
+- [apps](https://github.com/lordbasex/LordOS/tree/main/apps), [server/src/lpk.c](https://github.com/lordbasex/LordOS/blob/main/server/src/lpk.c), [tools/lpk.mjs](https://github.com/lordbasex/LordOS/blob/main/tools/lpk.mjs)
+- [server/src/pkg](https://github.com/lordbasex/LordOS/tree/main/server/src/pkg), [server/src/apps.c](https://github.com/lordbasex/LordOS/blob/main/server/src/apps.c)
+- [server/src/wasm/wasm.c](https://github.com/lordbasex/LordOS/blob/main/server/src/wasm/wasm.c), [server/src/ui/js_wasm.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/js_wasm.c)
+- [tools/install/install.sh](https://github.com/lordbasex/LordOS/blob/main/tools/install/install.sh)
+
+## 6. Security
+
+### 6.1 Threat model
+
+LordOS is designed against these threats:
+
+- **A malicious or compromised installed app** that wants the user's files, keys, microphone, camera, clipboard or network.
+- **Malicious documents and messages**: PDFs, archives, fonts, images, video and mail crafted to exploit a parser.
+- **A Linux app that wants to send data out**, or to escape the rules set for it.
+- **An attacker on the local network** trying to use the remote desktop or to tamper with downloads.
+- **Tampered packages and releases.**
+
+Outside the model, for now: a compromised kernel or root account; physical attacks; side channels; and Linux apps reading the user's files (they run as the user, as on any Debian system). Linux apps are confined only on the network.
+
+### 6.2 Least privilege
+
+- `lord-server` runs as the user. In a managed session it never holds the display or input devices itself: `lord-sessiond` lends them and revokes them.
+- Libraries that parse untrusted data are linked only by helpers: FFmpeg and libva by `lord-media`; Poppler and libarchive by `lord-doc`; OpenSSL by `lord-maild` and `lord-sessiond`; Monocypher by `lord-vault`.
+- Helpers receive files and devices as file descriptors opened by `lord-server`; they never open paths.
+- The compositor never waits for a helper or an app, so a crash or a hang stays contained.
+
+### 6.3 The root processes and their closed interfaces
+
+| Process | Accepts | Never does |
+|---|---|---|
+| `admin.c` helper | a fixed table of actions, arguments validated as root | generic actions, user text in a shell |
+| `lord-sessiond` | login requests from the greeter; short session JSON (≤ 4 KB) | let the greeter verify passwords; read pixels as root |
+| its cgroup placement child | `enter <scope> <limits>` for the calling process only, from a session's `server` leaf, running a binary from `lord-server`'s directory | place arbitrary processes; hand the tree back to the user |
+| `lord-netd` | `net-*` actions from root peers only | non-network actions; run anything from a session |
+| `lord-netperm` | `RELOAD` with no data | run programs; take arguments; open internet sockets |
+| `lord-fand` | `STATUS` for anyone; `PROFILE`, `CURVE`, `FORCE` for administrators | name paths or devices; run programs; use the network |
+
+### 6.4 The app sandbox
+
+Each `.lpk` app, and the Passwords app, runs as `lord-server --app <id>`: the same binary in "app mode", launched by `lord-server` with a validated package id as its only argument. The process connects to the compositor as a Wayland client and opens the broker socket, then applies the sandbox, and only then loads the app's code (`server/src/sec/sandbox.c`):
+
+- **Landlock** (ABI up to 6): read-only access to the package, the shared app runtime, fonts and libraries; read-write only to `~/.local/share/lordos/appdata/<id>`; scoping of abstract Unix sockets and signals.
+- **seccomp-bpf**: an allow list of system calls on every thread (TSYNC), without `ptrace`, `mount`, `kexec`, `bpf`, `perf_event_open`, `keyctl`, module loading or `execve`. New Unix sockets and `socketpair` are refused, because Landlock up to ABI 6 doesn't filter `connect` to named Unix sockets; this keeps the app away from the session bus, the print service and the Wayland socket.
+- **No privileges**: `no_new_privs`, an empty capability set and a dropped bounding set.
+- **cgroup v2**: `app-lordos-lpk-<id>.scope`, created by root, with `memory.high` 192 MB, `memory.max` 512 MB and one CPU core.
+- **Network**: without the `network` permission (declared **and** allowed), seccomp refuses internet sockets and Landlock refuses TCP connect and bind. Network namespaces are not used, because creating one needs privileges `lord-server` doesn't have.
+
+If a kernel feature is missing, the app still starts and the log says which part is missing. The deliberately malicious test app (`tests/lpk-evil`) fails at everything it tries; `build/sandbox-test` passes 14 of 14 checks for apps and 14 of 14 with network. Measured on a VM: about 13.7 MB of RSS per isolated app, a median start of 106 ms, and 0.89 ms to apply the sandbox.
+
+### 6.5 The broker, permissions and the file dialog
+
+**Figure: How a permission request travels.**
+
+```
+[Isolated app] Asks through the broker socket
+ │ request
+ ▼
+[Broker in lord-server] Looks up the stored decision (perms.c)
+ │ state is Ask
+ ▼
+[System prompt] Only if not decided yet; drawn by the session
+ │ shown
+ ▼
+[You decide] Allow or Don't Allow, saved in permisos.json
+ │ answer
+ ▼
+[Enforced] Broker checks every call; sandbox and kernel block the rest
+ │ later
+ ▼
+[Revocable] Settings → Privacy; camera and microphone stop at once
+```
+
+*The app never answers its own prompt: the decision is stored where it can't write, and checked in C on every request.*
+
+The isolated app talks to `lord-server` only over one `SOCK_SEQPACKET` socket. Every request is checked in C: file access only inside the app's own data folder; clipboard reads only with the `clipboard` permission; permission requests answered from the stored decision or, if none, by a **system-drawn prompt** (*Allow / Don't Allow*); camera and microphone only through `lord-server`.
+
+- **Decisions** are stored per user in `~/.config/lordos/permisos.json`, outside the app's reach. The lookup is O(1).
+- **The file dialog is LordOS's own powerbox** (`sdk/powerbox.jsx`), not `xdg-desktop-portal`: `lord-server` draws it, opens the chosen file and passes only that descriptor. The only desktop portal interface LordOS implements is `org.freedesktop.portal.Settings`, for GTK theming.
+- **Microphone:** `lord-server` owns the PipeWire stream and gives the app a read-only shared ring.
+- **Camera:** `lord-server` opens the device and gives it only to `lord-media`; the app gets a read-only view of the decoded frames and must acknowledge each one, and `lord-server` validates every acknowledgement.
+- **Revocation:** denying the camera or the microphone in Settings stops it at once (the app's `lord-media` is killed; the PipeWire stream is closed). The `network` permission is decided at launch.
+- **Keyring:** an isolated app's keyring requests carry an owner that `lord-server` sets from the verified app id.
+
+**Limits.** There is no "allow once". Some declared permissions (Bluetooth, launching apps, notifications) have no broker call yet, so isolated apps can't use those capabilities at all; listening on a port is governed by the network permission. A Linux app running as the user could edit the permissions file.
+
+### 6.6 The per-app firewall and the Monitor
+
+**Figure: The path of a connection.**
+
+```
+[App opens a connection] connect, sendto, bind or socket
+ │ system call
+ ▼
+[cgroup eBPF hook] In the kernel; finds the app by its scope
+ │ map lookup
+ ▼
+[Per-app rules] Restrictions, then the most specific rule, then trusted, then mode
+ │ decision
+ ▼
+[Allow or deny] Denied: the app gets EPERM
+ │ ring buffer
+ ▼
+[Monitor map] New connections and counters, once per second
+```
+
+*The decision happens in the kernel when the connection opens; nothing runs per packet.*
+
+`lord-netperm` enforces per-app network rules in the kernel. Linux apps opened from the app launcher run in `app-lordos-<id>.scope`, `.lpk` apps in `app-lordos-lpk-<id>.scope`, and the rest of the session counts as `lordos`. All scopes are root-owned. The service loads seven cgroup eBPF programs (`connect4/6`, `sendmsg4/6`, `bind4/6`, `sock_create`) into the cgroup of `lordos.service`, finds each process's app by its cgroup ancestor, and returns allow or deny (`EPERM`). The programs are compiled into the binary and loaded with LordOS's own loader over the `bpf()` system call; libbpf and bcc are not used.
+
+- **Rules** support exact domains, wildcards, IPv4/IPv6 networks, `lan`, `internet`, ports, protocols and direction. Restrictions (no internet, no LAN, no network, no incoming) come first; then the most specific rule wins, with deny beating allow at equal specificity; then trusted apps; then the mode (silent, the default, or off). `npcompile.c` precomputes this into hash and longest-prefix-match maps. A test runs the kernel's decision code against the reference decision maker over 480,000 random connections: 0 differences.
+- **Domain names** come only from the system resolver: systemd-resolved's monitor interface or, without it, replies from port 53 of the configured servers read by a receive-only packet socket. Answers an app received on its own sockets are never trusted.
+- **Escapes.** The cgroup tree is root-owned, so an app can't move itself. A process that asks the user's systemd manager for a new unit (`systemd-run --user`) lands under `user@<uid>.service`; `lord-netperm` attaches the same programs there and holds such processes to the strictest union of that user's running restricted apps. Tested: all escape attempts denied, other users unaffected.
+- **Cost**: about 0.5 µs per UDP connect, TCP within noise, no change in throughput, since nothing runs per packet.
+- **The Monitor** shows each app's connections (from `sock_diag`), bytes, destinations by country from a local database, and a per-app Rule switch. No address ever leaves the machine for lookups: no reverse DNS, no online geolocation.
+
+**Limits.** "Ask" mode is designed but behaves as silent today. There is no interface yet for domain rules or per-destination switches (the engine and the API support them). ICMP is blocked only by "no network"; connections to an already-open port aren't checked. Settings also offers non-network restrictions (camera, microphone, screen, USB, Bluetooth, files, notifications): they are stored, but **no component enforces them yet**.
+
+### 6.7 Helpers that process untrusted data
+
+**Figure: Opening an untrusted file.**
+
+```
+[App asks to open a file] PDF, archive, video, photo, mail
+ │ request
+ ▼
+[lord-server] Validates the path and opens the file
+ │ file descriptor
+ ▼
+[Sandboxed helper] Parses with FFmpeg, Poppler, libarchive or OpenSSL; no network, no exec
+ │ sealed memfd
+ ▼
+[Sealed shared memory] Pixels or pages, validated by lord-server
+```
+
+*A malicious file can crash its helper, but the helper can't reach the network, run programs or open other files.*
+
+`lord-doc` (PDF, archives, fonts, scanner images), `lord-media` (video, audio, photos, camera), `lord-maild` (mail, calendars, contacts) and `lord-vault` (secrets) share one hardened sandbox, `sandbox_apply_helper()`:
+
+- no `socket`, `socketpair`, `connect`, `bind`, `listen`, `accept`; no `execve`; `clone` only for threads; seccomp on every thread, and if seccomp can't be applied the helper exits;
+- files only through descriptors passed by `lord-server`; ioctls only by class (DRM, V4L2, DMA-BUF) where needed;
+- results returned in sealed shared memory, validated by `lord-server`.
+
+`lord-media` doesn't even receive the PipeWire socket; audio flows through a shared ring whose stream belongs to `lord-server`. `lord-maild` can't create sockets: it asks `lord-server`, which connects only to servers in the accounts file (and, after the user asks to load images, only to public addresses on ports 80/443 for ten minutes) and hands over the connected socket. `build/sandbox-test helper` passes 17 of 17 checks.
+
+### 6.8 Package signing and trust levels
+
+`.lpk` packages carry a manifest of every file's SHA-256 and an Ed25519 signature over it. SHA-256 and Ed25519 are LordOS's own code (Ed25519 following TweetNaCl's arithmetic), tested against NIST and RFC 8032 vectors (55 of 55). Verification happens in C at install and at load. The Store shows the trust level: **LordOS** (official key, compiled into the binary so no file can add one), **Verified author** (listed in the signed catalog), **Signed by <name>**, or **Unsigned** with a warning. Updates must be signed with the same key. A signed catalog carries a revocation list. If you edit an installed app, LordOS marks it "Modified by you", can restore the original, or can share your version signed with your own key, with credit to the original.
+
+**Status:** official packages are signed today with a development key; the final key replaces it for the public release. A signed LordOS app repository for the Store is not built yet.
+
+### 6.9 Release signing
+
+Every release file (the `.deb`, the ISO and the Raspberry Pi image) is listed with its SHA-256 in `SHA256SUMS`, and `SHA256SUMS` is signed with the LordOS release key (Ed25519). The public key is `tools/release/lordos-release.pub.pem`, also embedded in the Debian installer. Its fingerprint (SHA-256 of the DER public key) is:
+
+`c7155b8e6bbbb180f907381994d06af76d333016cd6f3facf67cadd053ea108e`
+
+The private key lives only on the maintainer's machine, never in the repository or on a build machine. §11 shows how to check a download.
+
+### 6.10 The vault
+
+`lord-vault` keeps passwords and the session keyring in `.lvault` files: one random 32-byte vault key, wrapped once per unlock method (Argon2id password with a cost calibrated per machine, FIDO2 `hmac-secret` with LordOS's own CTAP2 client, key file, password plus key file, recovery key); content sealed with XChaCha20-Poly1305 with the whole header as associated data; attachments sealed separately; atomic saves with a backup. Every flipped byte and every truncation is detected (1,165 of 1,165 in the test). Secrets live in an `mlock`ed arena excluded from core dumps and wiped on free, in a process that is not dumpable. The Passwords window runs in its own sandboxed process, so revealed values never enter the desktop's JavaScript. The keyring opens at login with the password `lord-sessiond` verified, and serves Linux apps through LordOS's own Secret Service implementation. Real hardware security keys are not yet tested.
+
+### 6.11 Protected windows
+
+A window marked protected (Passwords is) is painted black in every path that copies pixels out: screenshots, recordings, thumbnails, the remote desktop, and Wayland menus and fullscreen. The real monitor shows it normally. Linux apps have no screen-capture protocol to begin with.
+
+### Source files
+
+- [server/src/sec/sandbox.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/sandbox.c), [server/src/sec/brokersrv.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/brokersrv.c), [server/src/sec/perms.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/perms.c), [server/src/sec/cgroup.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/cgroup.c)
+- [server/src/netperm/np.bpf.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/np.bpf.c), [server/src/netperm/netperm.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/netperm.c), [server/src/fw/rules.c](https://github.com/lordbasex/LordOS/blob/main/server/src/fw/rules.c)
+- [server/src/sec/sign.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/sign.c), [server/src/pkg/crypto.c](https://github.com/lordbasex/LordOS/blob/main/server/src/pkg/crypto.c), [tools/release/sign-release.sh](https://github.com/lordbasex/LordOS/blob/main/tools/release/sign-release.sh)
+- [server/src/vault/vault.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/vault.c), [server/src/vault/vfile.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/vfile.c)
+- [server/src/media/capture.c](https://github.com/lordbasex/LordOS/blob/main/server/src/media/capture.c)
+
+## 7. Performance
+
+All figures below were measured by the project and are documented in the files cited. Most come from virtual machines; real-hardware measurements are noted as such.
+
+### 7.1 Memory and idle
+
+| Measurement | Value | Where |
+|---|---|---|
+| Whole system, live ISO, idle after a minute (4 GB, 4 cores) | 465 MB used, CPU 99 % idle | VM 117, `docs/ISO.md` |
+| Whole system, installed from the ISO, idle | 487 MB used, CPU 99 % idle | VM 120, `docs/ISO.md` |
+| Boot, live ISO with UEFI | 16.3 s (4.9 s kernel + 11.4 s userspace) | VM 117, `docs/ISO.md` |
+| `lord-server` without a 3D card (Mesa not loaded) | about 32 MB RSS | `docs/GPU.md` |
+| A user session (`lord-server`), remote desktop tests | about 50 MB; login screen 41 MB | VM 118, `docs/REMOTE.md` |
+| One isolated `.lpk` app | 13.7 MB RSS | VM 122, `docs/PRIVACY.md` |
+
+### 7.2 Drawing
+
+- Dragging a window on one 1280×800 display on the CPU path: about 6.7–6.9 ms of work per frame, around 120 frames per second (VM 118, `docs/DISPLAYS.md`).
+- The same window on a 2560×1600 display at 150 %: about 5.1 ms per frame.
+- Video: painting straight from the decoded frame when only an opaque video changed brought `lord-server` from 42 % to 13 % of a core for a windowed 1080p video, and from 92 % to 15 % fullscreen (`docs/ROADMAP.md`, media).
+- The Monitor closed costs nothing: its sampling thread doesn't exist until opened (`docs/MONITOR.md`).
+
+### 7.3 GPU
+
+On the VMs only a software renderer was available. With it, the CPU path is cheaper than "GPU" composition, which is why LordOS uses the CPU path when the only renderer is a software one. The GPU path's real benefit (composition and present close to free, zero-copy fullscreen) is expected on real cards, but **real AMD and Nvidia hardware has not been measured yet**.
+
+### 7.4 The Raspberry Pi 5
+
+The Raspberry Pi 5 is the only supported board. Results on a real board (16 GB, SD card, without a monitor), from `docs/RASPBERRY.md`:
+
+| Measurement | Value |
+|---|---|
+| Building every LordOS binary on the board | 1 min 02 s, 0 warnings |
+| `make -C server test` | 23 passed, 0 failed, 0 skipped |
+| NEON blit and mask vs. plain C | 9.90 → 4.33 ms and 11.09 → 5.49 ms per screen (2.0–2.3×), bit-identical |
+| Idle at the login screen, headless | `lord-server` 36 MB RSS, 0.6 % CPU; system 450 MB of 16 GB; 38–43 °C, no throttling |
+| Building the SD image on the board | 8 min 18 s; 503 MB compressed |
+| Building the LordOS kernel on the board | about 50 min per flavour |
+
+**The LordOS kernel.** The Raspberry Pi's own kernel doesn't build Landlock. Without it, the document-helper hostile test fails 5 of its 25 filesystem checks and the sandbox test can't run. LordOS builds the Raspberry Pi kernel from its own source and default configuration, changing only three options (Landlock on, the LSM list, the version suffix), and pins it so a newer archive kernel can't replace it. The image also enables the memory cgroup, which Raspberry Pi turns off at boot.
+
+**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`).
+
+**Not verified yet on the board:** anything with a monitor attached (modesetting, GPU composition on screen, frame rates), the desktop session, and booting the built image.
+
+### 7.5 Modern PCs
+
+There are no measurements on real PCs in the repository yet. The ISO is tested on virtual machines (UEFI and BIOS); testing on a real AMD machine from the live USB is planned.
+
+### Source files
+
+- [docs/ISO.md](https://github.com/lordbasex/LordOS/blob/main/docs/ISO.md), [docs/RASPBERRY.md](https://github.com/lordbasex/LordOS/blob/main/docs/RASPBERRY.md), [docs/FANS.md](https://github.com/lordbasex/LordOS/blob/main/docs/FANS.md), [docs/DISPLAYS.md](https://github.com/lordbasex/LordOS/blob/main/docs/DISPLAYS.md)
+- [tools/rpi/build-kernel.sh](https://github.com/lordbasex/LordOS/blob/main/tools/rpi/build-kernel.sh), [tools/rpi/build-img.sh](https://github.com/lordbasex/LordOS/blob/main/tools/rpi/build-img.sh)
+- [server/src/canvas.c](https://github.com/lordbasex/LordOS/blob/main/server/src/canvas.c)
+
+## 8. Visual experience
+
+- **A design guide.** Apps follow a shared guide (`docs/DESIGN.md`): an 8 px spacing grid, a small type scale, consistent control heights and one accent-coloured action per view. The tokens are exported by the SDK (`spacing`, `typeScale`, `controlSize`), and every app went through documented before-and-after polish passes in light, dark, right-to-left and small windows.
+- **Themes.** A theme is a complete desktop written in React: menu bar, Dock, app launcher, Control Center and window frame, plus its tokens. LordOS ships a default theme with a menu bar and a Dock, and a Classic theme with a taskbar and a start menu. Themes switch live; settings persist.
+- **Light and dark, accents.** Both modes and the accent colour apply live to native apps, isolated apps and, through the portal and GSettings, GTK apps.
+- **Right to left.** The whole interface mirrors for Arabic, Hebrew and similar scripts, including isolated apps, which follow the session's language live.
+- **Lumo.** LordOS's mascot is Lumo, a small celestial fox, used in welcome screens, empty states and brand material, with a fixed set of poses defined in the brand guide.
+- **Accessibility today:** a "reduce motion" setting that turns off decorative animations, keyboard shortcuts throughout, and scalable displays up to 200 %. A screen reader, zoom and high contrast are on the roadmap and **not built yet**.
+
+### Source files
+
+- [docs/DESIGN.md](https://github.com/lordbasex/LordOS/blob/main/docs/DESIGN.md), [docs/LORDOS-BRAND.md](https://github.com/lordbasex/LordOS/blob/main/docs/LORDOS-BRAND.md)
+- [themes](https://github.com/lordbasex/LordOS/tree/main/themes), [sdk/controls.jsx](https://github.com/lordbasex/LordOS/blob/main/sdk/controls.jsx), [sdk/i18n.js](https://github.com/lordbasex/LordOS/blob/main/sdk/i18n.js)
+
+## 9. Extensibility
+
+- **The SDK** (`@lordos/sdk`) is the only thing apps import: windows, settings, theme tokens, controls, files, media, notifications, keyring, printing and more. Apps don't import from themes, so any app works in any theme.
+- **Writing an app** means a folder with `manifest.json` and `index.jsx`. `node tools/lpk.mjs <folder>` bundles it without React or the SDK, adds the icon and translations, and signs it if a key is given; `keygen`, `sign`, `verify` and `catalog` cover the rest. Apps can include WebAssembly modules and draw raw pixels with `<Image pixels>`.
+- **Themes** follow a fixed contract (`Desktop`, `MenuBar`, `Dock`, `Launcher`, `ControlCenter`, `WindowFrame`, tokens), documented in `themes/README.md`, with the Classic theme as a template.
+- **Linux interoperability** is through standards: Wayland, the Settings portal, the Secret Service, the notifications service, `mimeapps.list` default apps and `.desktop` files.
+- **Automation:** there is no scripting or automation API beyond the SDK today. Integrations with AI assistants (for example through the Model Context Protocol) **do not exist in LordOS**; they are only a possible future direction and would have to respect the same rule that JavaScript can't execute commands.
+
+### Source files
+
+- [sdk](https://github.com/lordbasex/LordOS/tree/main/sdk), [apps/README.md](https://github.com/lordbasex/LordOS/blob/main/apps/README.md), [themes/README.md](https://github.com/lordbasex/LordOS/blob/main/themes/README.md)
+- [docs/NATIVE-APPS.md](https://github.com/lordbasex/LordOS/blob/main/docs/NATIVE-APPS.md), [docs/WASM.md](https://github.com/lordbasex/LordOS/blob/main/docs/WASM.md), [examples/apps/fractal](https://github.com/lordbasex/LordOS/tree/main/examples/apps/fractal)
+
+## 10. Roadmap and limitations
+
+### 10.1 Where things stand
+
+Milestones M1 to M9 are complete in 0.7.0 Beta: the display server, the UI engine, the SDK and themes, the terminal, languages and complex scripts, Linux app compatibility, packages and system services, sessions, isolation and the firewall, and the M9 app suites (documents and printing, media, system apps, passwords, hardware settings, mail and calendar). The final ISO was built and tested on virtual machines on 18 October 2026.
+
+### 10.2 Known limitations
+
+- Real hardware: AMD and Nvidia GPUs, real monitors, laptops (battery, backlight, lid), Bluetooth controllers, printers and scanners, FIDO2 keys and real mail providers are untested.
+- The Raspberry Pi 5 hasn't been tested with a monitor, and its built image hasn't been booted yet.
+- Linux apps are not sandboxed; no Xwayland.
+- Firewall: no ask mode, no domain-rule interface, non-network restrictions not enforced.
+- Permissions: no "allow once"; camera and microphone use by Linux apps isn't shown.
+- Secure Boot must be turned off; signing with a shim is pending.
+- Package downloads use HTTP (signed and hashed).
+- Remote desktop has no audio.
+- Accessibility (screen reader, zoom, high contrast) is not built.
+
+### 10.3 Next
+
+Before the final release: the final ISO with everything and a Raspberry Pi 5 image tested on the real board. After it, as planned in `docs/ROADMAP.md`: a desktop virtualization app built on KVM and QEMU; an Android container with LineageOS and apps from LordOS's Store; the firewall's ask mode; accessibility; and a full demo video.
+
+### Source files
+
+- [docs/ROADMAP.md](https://github.com/lordbasex/LordOS/blob/main/docs/ROADMAP.md), [CHANGELOG.md](https://github.com/lordbasex/LordOS/blob/main/CHANGELOG.md)
+
+## 11. How to verify the project yourself
+
+### 11.1 Build it
+
+On a development machine with Node.js, bundle the themes, SDK and apps:
+
+```
+npm install && npm run build
+```
+
+On Debian 13, build the binaries and run the tests:
+
+```
+sudo apt-get install -y --no-install-recommends build-essential
+make -C server -j4
+make -C server test # every self-contained suite
+make -C server test-full # adds the helpers, the sandbox and the HarfBuzz comparison
+```
+
+`make test` fails if any suite fails; a suite whose tool or data isn't installed reports "skipped" rather than passing silently. The sandbox tests need a kernel with Landlock. The ISO and the Raspberry Pi image are built as described in `docs/ISO.md` and `docs/RASPBERRY.md`.
+
+### 11.2 What the tests cover
+
+- **Terminal and text:** the VT emulator, OpenType shaping against HarfBuzz, Unicode bidi against the official test file, input methods, Thai word breaking against libthai.
+- **Security:** the sandbox (app, network, helper), signing (NIST and RFC 8032 vectors), package state, archive path rules against malicious archives, `lord.fs` protections, the firewall rules (with 20,000 JSON mutations and 30,000 random operations against a linear reference), the DNS reader (200,000 random packets), the kernel-map compiler (480,000 connections), and the kernel integration test (18 of 18 on a VM).
+- **Parsers:** mail, MIME, HTML sanitizer, iCalendar, vCard and XML (30,953 checks with mutation fuzzing), the vault format, importers, QR, CBOR, D-Bus marshalling, the country database reader, journal, TZif and IPP.
+- **Engine and hardware:** layout and painting, NEON vs. C, the touchpad driver with recorded gestures, fans on fake sysfs trees, display arrangement, sound, and the WebAssembly specification suite.
+
+On the final ISO build: `make -C server test` reported 23 passed, 0 failed, 1 skipped (bidi data not installed).
+
+### 11.3 Check a release
+
+Download `SHA256SUMS`, `SHA256SUMS.sig`, the release files and the public key (`tools/release/lordos-release.pub.pem`). Check that the key's fingerprint is `c7155b8e6bbbb180f907381994d06af76d333016cd6f3facf67cadd053ea108e`, then, with OpenSSL 3:
+
+```
+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
+```
+
+### 11.4 Check a running system
+
+- `systemctl status lord-netperm lord-fand lordos` shows the services; the ISO test confirmed seven BPF programs attached.
+- `cat /proc/<pid>/status | grep -E 'Seccomp|NoNewPrivs'` on a `lord-server --app` process shows the sandbox.
+- `systemd-cgls` shows the root-owned `lordos-session-<uid>` tree with one scope per app.
+- Remote desktop: `ss -ltn` shows nothing on port 5673 until you enable it in Settings → Sharing.
+
+## 12. License and credits
+
+LordOS's code is released under the **MIT license**. Third-party components keep their own licenses, listed in `THIRD_PARTY.md`: QuickJS and stb (vendored), Monocypher (CC0/BSD-2), the EFF word list (CC BY 3.0 US), the common-password list (MIT), DB-IP Lite country data (CC BY 4.0), Natural Earth (public domain), and the Inter, JetBrains Mono and Plus Jakarta Sans fonts (OFL).
+
+LordOS is created by the **IPERFEX** group: **Pablo Miranda** and **Federico Pereira**.
+
+## 13. Glossary
+
+- **Broker:** the single socket through which an isolated app asks `lord-server` for anything that touches the user's things; every request is checked in C.
+- **cgroup (v2):** a kernel mechanism that groups processes to account for and limit resources. LordOS gives each app its own group, a "scope", and uses it to identify the app in the firewall.
+- **Compositor:** the program that combines the windows of all apps into the final image on screen.
+- **DRM/KMS:** the kernel interfaces for graphics devices and for setting display modes.
+- **eBPF:** small verified programs that run inside the kernel; LordOS attaches them to cgroups to decide network connections.
+- **evdev:** the kernel interface for input devices.
+- **Helper:** a small LordOS process that handles untrusted data or secrets in a stricter sandbox (`lord-doc`, `lord-media`, `lord-maild`, `lord-vault`).
+- **Landlock:** a kernel feature that lets an unprivileged process restrict which files and network ports it, and its children, may use.
+- **`.lpk`:** LordOS's package format for installable native apps.
+- **`.lvault`:** LordOS's encrypted vault file format.
+- **Powerbox:** a file dialog drawn by the system that hands the app only the file the user chose.
+- **QuickJS:** a small JavaScript engine written in C.
+- **Scope:** a cgroup for one app, such as `app-lordos-lpk-<id>.scope`.
+- **seccomp-bpf:** a kernel filter that restricts which system calls a process may make.
+- **Secret Service:** the freedesktop D-Bus standard Linux apps use to store secrets.
+- **Wayland:** the protocol between graphical apps and the compositor.
+
+## 14. Where to read more
+
+| Chapter | Documents in `docs/` |
+|---|---|
+| 1. Vision | ARCHITECTURE.md, LORDOS-BRAND.md |
+| 2. Architecture | ARCHITECTURE.md, NETWORK.md, FANS.md, SETTINGS.md, SYSTEM.md |
+| 3. Compositor | GPU.md, DISPLAYS.md, WINDOWS.md, TRACKPAD.md, WAYLAND.md, SESSIONS.md, REMOTE.md |
+| 4. UI engine | ARCHITECTURE.md, LANGUAGES.md, TERMINAL.md |
+| 5. Applications | NATIVE-APPS.md, PACKAGES.md, WASM.md, FILES.md, MEDIA.md, DOCUMENTS.md, MAIL.md, ISO.md, INSTALL-DEBIAN.md |
+| 6. Security | PRIVACY.md, FIREWALL.md, MONITOR.md, SIGNING.md, PASSWORDS.md, MEDIA.md, REMOTE.md |
+| 7. Performance | ISO.md, RASPBERRY.md, FANS.md, DISPLAYS.md, GPU.md |
+| 8. Visual experience | DESIGN.md, LORDOS-BRAND.md, LANGUAGES.md, DOCK.md |
+| 9. Extensibility | NATIVE-APPS.md, WASM.md, and `apps/README.md`, `themes/README.md` |
+| 10. Roadmap | ROADMAP.md and `CHANGELOG.md` |
diff --git a/docs/TERMINAL.md b/docs/TERMINAL.md
index ab4ec9f..9188553 100644
--- a/docs/TERMINAL.md
+++ b/docs/TERMINAL.md
@@ -1,7 +1,7 @@
# LordOS Terminal
LordOS's native terminal, inspired by popular terminal emulators. It isn't a Linux app running inside LordOS:
-the emulation, the PTY and the drawing are written from scratch in C inside `lord-server`,
+the emulation, the PTY and the drawing are LordOS's own C code inside `lord-server`,
and the UI (tabs, panes, profiles, menus) is a React app like the others.
```
diff --git a/web/content/faq/faq.json b/web/content/faq/faq.json
new file mode 100644
index 0000000..282d14d
--- /dev/null
+++ b/web/content/faq/faq.json
@@ -0,0 +1,796 @@
+{
+ "categories": [
+ {
+ "id": "about",
+ "title": {
+ "en": "About LordOS",
+ "es": "Sobre LordOS",
+ "pt": "Sobre o LordOS"
+ },
+ "items": [
+ {
+ "id": "what-is-lordos",
+ "q": {
+ "en": "What is LordOS?",
+ "es": "¿Qué es LordOS?",
+ "pt": "O que é o LordOS?"
+ },
+ "a": {
+ "en": "LordOS is a free Debian-based GNU/Linux distribution with its own desktop environment. Its display server, Wayland compositor, interface engine and more than 35 native apps are built from their fundamental components on top of Debian, with a light, private and fast desktop as the goal.",
+ "es": "LordOS es una distribución GNU/Linux libre basada en Debian, con su propio entorno de escritorio. Su servidor gráfico, su compositor Wayland, su motor de interfaz y más de 35 apps nativas están construidos desde sus componentes fundamentales sobre Debian, con el objetivo de un escritorio liviano, privado y rápido.",
+ "pt": "O LordOS é uma distribuição GNU/Linux livre baseada no Debian, com seu próprio ambiente de desktop. O servidor gráfico, o compositor Wayland, o motor de interface e mais de 35 apps nativos são construídos a partir de seus componentes fundamentais sobre o Debian, com o objetivo de um desktop leve, privado e rápido."
+ }
+ },
+ {
+ "id": "distro-or-desktop",
+ "q": {
+ "en": "Is it a distribution or a desktop environment?",
+ "es": "¿Es una distribución o un entorno de escritorio?",
+ "pt": "É uma distribuição ou um ambiente de desktop?"
+ },
+ "a": {
+ "en": "Both. You can install LordOS as a complete distribution from the ISO or the Raspberry Pi image, or add the LordOS desktop to an existing Debian 13 system with a single command. In both cases the base system comes from Debian.",
+ "es": "Las dos cosas. Podés instalar LordOS como distribución completa desde la ISO o la imagen para Raspberry Pi, o sumar el escritorio de LordOS a un Debian 13 que ya tengas con un solo comando. En los dos casos, el sistema base viene de Debian.",
+ "pt": "Os dois. Você pode instalar o LordOS como distribuição completa a partir da ISO ou da imagem para Raspberry Pi, ou adicionar o desktop do LordOS a um Debian 13 que você já tem com um único comando. Nos dois casos, o sistema base vem do Debian."
+ }
+ },
+ {
+ "id": "based-on-debian",
+ "q": {
+ "en": "Is it based on Debian?",
+ "es": "¿Está basada en Debian?",
+ "pt": "É baseada no Debian?"
+ },
+ "a": {
+ "en": "Yes, on Debian 13. The kernel, drivers, Mesa, PipeWire, CUPS, BlueZ and every package in the Store come from Debian's own mirrors and keep Debian's security updates. LordOS replaces only the graphical layer: there is no X11, GNOME or KDE underneath.",
+ "es": "Sí, en Debian 13. El kernel, los drivers, Mesa, PipeWire, CUPS, BlueZ y todos los paquetes de la Tienda vienen de los mirrors de Debian y reciben sus actualizaciones de seguridad. LordOS reemplaza solo la capa gráfica: abajo no hay X11, GNOME ni KDE.",
+ "pt": "Sim, no Debian 13. O kernel, os drivers, o Mesa, o PipeWire, o CUPS, o BlueZ e todos os pacotes da Loja vêm dos espelhos do Debian e recebem as atualizações de segurança dele. O LordOS substitui só a camada gráfica: por baixo não há X11, GNOME nem KDE."
+ }
+ },
+ {
+ "id": "why-not-gnome-kde",
+ "q": {
+ "en": "Why not just use GNOME or KDE?",
+ "es": "¿Por qué no usar GNOME o KDE?",
+ "pt": "Por que não usar GNOME ou KDE?"
+ },
+ "a": {
+ "en": "We want a complete desktop that runs well on modest hardware: an idle LordOS session uses about 120 MB of memory and no CPU. Building our own environment also lets us design privacy in from the start, with per-app isolation, permissions and a visible firewall. GTK (GNOME) and Qt (KDE) apps still run on LordOS.",
+ "es": "Queremos un escritorio completo que ande bien en equipos modestos: una sesión de LordOS en reposo usa unos 120 MB de memoria y nada de CPU. Tener nuestro propio entorno también nos deja pensar la privacidad desde el principio, con aislamiento por app, permisos y un firewall visible. Las apps GTK (GNOME) y Qt (KDE) igual funcionan en LordOS.",
+ "pt": "Queremos um desktop completo que rode bem em hardware modesto: uma sessão do LordOS em repouso usa cerca de 120 MB de memória e nada de CPU. Ter nosso próprio ambiente também permite pensar a privacidade desde o começo, com isolamento por app, permissões e um firewall visível. Os apps GTK (GNOME) e Qt (KDE) continuam funcionando no LordOS."
+ }
+ },
+ {
+ "id": "who-makes-it",
+ "q": {
+ "en": "Who makes LordOS?",
+ "es": "¿Quién hace LordOS?",
+ "pt": "Quem faz o LordOS?"
+ },
+ "a": {
+ "en": "LordOS is made by the IPERFEX group, by Pablo Miranda and Federico Pereira, in Argentina.",
+ "es": "LordOS lo hace el grupo IPERFEX, de Pablo Miranda y Federico Pereira, en Argentina.",
+ "pt": "O LordOS é feito pelo grupo IPERFEX, de Pablo Miranda e Federico Pereira, na Argentina."
+ }
+ },
+ {
+ "id": "is-it-free",
+ "q": {
+ "en": "Is it free?",
+ "es": "¿Es gratis?",
+ "pt": "É grátis?"
+ },
+ "a": {
+ "en": "Yes. LordOS is free to download and use, with no accounts, ads or paid editions. If it helps you, you can [support the project](/#support) with a voluntary donation.",
+ "es": "Sí. LordOS es gratis para descargar y usar, sin cuentas, publicidad ni ediciones pagas. Si te sirve, podés [apoyar el proyecto](/#support) con una donación voluntaria.",
+ "pt": "Sim. O LordOS é grátis para baixar e usar, sem contas, anúncios nem edições pagas. Se ele te ajudar, você pode [apoiar o projeto](/#support) com uma doação voluntária."
+ }
+ },
+ {
+ "id": "license",
+ "q": {
+ "en": "What is the license?",
+ "es": "¿Qué licencia tiene?",
+ "pt": "Qual é a licença?"
+ },
+ "a": {
+ "en": "LordOS's own code is under the MIT license, so you can use, study, change and share it. Bundled components and Debian packages keep their own licenses; see [Licenses](/legal/licenses/). The name, the crown logo and Lumo follow the [Trademark policy](/legal/trademark/).",
+ "es": "El código propio de LordOS está bajo la licencia MIT: podés usarlo, estudiarlo, cambiarlo y compartirlo. Los componentes incluidos y los paquetes de Debian mantienen sus propias licencias; mirá [Licencias](/legal/licenses/). El nombre, el logo de la corona y Lumo siguen la [Política de marca](/legal/trademark/).",
+ "pt": "O código próprio do LordOS está sob a licença MIT: você pode usar, estudar, alterar e compartilhar. Os componentes incluídos e os pacotes do Debian mantêm suas próprias licenças; veja [Licenças](/legal/licenses/). O nome, o logo da coroa e o Lumo seguem a [Política de marca](/legal/trademark/)."
+ }
+ },
+ {
+ "id": "production-ready",
+ "q": {
+ "en": "Is it ready for everyday use?",
+ "es": "¿Está lista para usar todos los días?",
+ "pt": "Está pronto para o dia a dia?"
+ },
+ "a": {
+ "en": "Not yet: LordOS 0.7.0 is the first public beta. Most of it works, but some parts haven't been tested on real hardware yet (for example the Raspberry Pi 5 desktop, real printers and NVIDIA cards), and features such as accessibility tools are still to come. Try it live or on a spare computer, and keep backups.",
+ "es": "Todavía no: LordOS 0.7.0 es la primera beta pública. Casi todo funciona, pero algunas partes todavía no se probaron en hardware real (por ejemplo el escritorio en la Raspberry Pi 5, impresoras reales y placas NVIDIA), y faltan cosas como las herramientas de accesibilidad. Probala en modo live o en una compu de repuesto, y hacé copias de seguridad.",
+ "pt": "Ainda não: o LordOS 0.7.0 é o primeiro beta público. Quase tudo funciona, mas algumas partes ainda não foram testadas em hardware real (por exemplo o desktop no Raspberry Pi 5, impressoras reais e placas NVIDIA), e recursos como as ferramentas de acessibilidade ainda estão por vir. Experimente no modo live ou num computador reserva, e faça backups."
+ }
+ }
+ ]
+ },
+ {
+ "id": "install",
+ "title": {
+ "en": "Download and install",
+ "es": "Descarga e instalación",
+ "pt": "Download e instalação"
+ },
+ "items": [
+ {
+ "id": "requirements",
+ "q": {
+ "en": "What do I need to run LordOS?",
+ "es": "¿Qué necesito para usar LordOS?",
+ "pt": "Do que eu preciso para rodar o LordOS?"
+ },
+ "a": {
+ "en": "A 64-bit PC (x86-64) or a Raspberry Pi 5, a USB stick of at least 1 GB for the ISO, and a disk of at least 8 GB to install it. A 3D graphics card is optional: without one, LordOS draws with the CPU.",
+ "es": "Una PC de 64 bits (x86-64) o una Raspberry Pi 5, un pendrive de al menos 1 GB para la ISO y un disco de al menos 8 GB para instalarla. La placa de video 3D es opcional: sin ella, LordOS dibuja con la CPU.",
+ "pt": "Um PC de 64 bits (x86-64) ou um Raspberry Pi 5, um pendrive de pelo menos 1 GB para a ISO e um disco de pelo menos 8 GB para instalar. A placa de vídeo 3D é opcional: sem ela, o LordOS desenha com a CPU."
+ }
+ },
+ {
+ "id": "64-bit-pc",
+ "q": {
+ "en": "Which processors are supported?",
+ "es": "¿Qué procesadores soporta?",
+ "pt": "Quais processadores são suportados?"
+ },
+ "a": {
+ "en": "On PCs, 64-bit x86 processors (amd64) from Intel and AMD. On ARM, only the Raspberry Pi 5 is supported. There are no 32-bit images.",
+ "es": "En PC, procesadores x86 de 64 bits (amd64) de Intel y AMD. En ARM, solo la Raspberry Pi 5. No hay imágenes de 32 bits.",
+ "pt": "No PC, processadores x86 de 64 bits (amd64) da Intel e da AMD. Em ARM, só o Raspberry Pi 5. Não há imagens de 32 bits."
+ }
+ },
+ {
+ "id": "how-much-ram",
+ "q": {
+ "en": "How much memory does it need?",
+ "es": "¿Cuánta memoria necesita?",
+ "pt": "Quanta memória ele precisa?"
+ },
+ "a": {
+ "en": "An idle LordOS session uses about 120 MB, and the whole live system used about 465 MB on a 4 GB test machine. We haven't published an official minimum yet; the apps you open (a web browser, above all) decide how much more you need. On the Raspberry Pi 5, 4 GB works and 8 or 16 GB is recommended.",
+ "es": "Una sesión de LordOS en reposo usa unos 120 MB, y el sistema live completo usó unos 465 MB en una máquina de prueba de 4 GB. Todavía no publicamos un mínimo oficial; cuánto más necesitás depende de las apps que abras (sobre todo el navegador). En la Raspberry Pi 5 anda con 4 GB y se recomiendan 8 o 16 GB.",
+ "pt": "Uma sessão do LordOS em repouso usa cerca de 120 MB, e o sistema live completo usou cerca de 465 MB numa máquina de teste de 4 GB. Ainda não publicamos um mínimo oficial; quanto a mais você precisa depende dos apps que abrir (principalmente o navegador). No Raspberry Pi 5, 4 GB funcionam e 8 ou 16 GB são recomendados."
+ }
+ },
+ {
+ "id": "uefi-bios",
+ "q": {
+ "en": "Does it boot with UEFI or legacy BIOS?",
+ "es": "¿Arranca con UEFI o BIOS?",
+ "pt": "Ele inicia com UEFI ou BIOS legado?"
+ },
+ "a": {
+ "en": "Both: the ISO is hybrid and works with UEFI and with BIOS/Legacy, and the installer sets up the disk for both. Secure Boot has to be turned off for now. Write the ISO with dd, balenaEtcher, Ventoy or Rufus in DD mode.",
+ "es": "Con los dos: la ISO es híbrida y funciona con UEFI y con BIOS/Legacy, y el instalador prepara el disco para ambos. Por ahora tenés que desactivar Secure Boot. Grabá la ISO con dd, balenaEtcher, Ventoy o Rufus en modo DD.",
+ "pt": "Com os dois: a ISO é híbrida e funciona com UEFI e com BIOS/Legacy, e o instalador prepara o disco para ambos. Por enquanto o Secure Boot precisa estar desligado. Grave a ISO com dd, balenaEtcher, Ventoy ou Rufus no modo DD."
+ }
+ },
+ {
+ "id": "live-mode",
+ "q": {
+ "en": "Can I try it without installing?",
+ "es": "¿Puedo probarla sin instalar?",
+ "pt": "Posso experimentar sem instalar?"
+ },
+ "a": {
+ "en": "Yes. Boot the ISO from a USB stick and LordOS starts in live mode, without touching your disk; changes are kept in memory and disappear when you turn it off. The boot menu also offers Spanish and Portuguese, a safe mode without the GPU and a copy-to-RAM option.",
+ "es": "Sí. Arrancá la ISO desde un pendrive y LordOS inicia en modo live, sin tocar tu disco; los cambios quedan en memoria y se pierden al apagar. El menú de arranque también ofrece español y portugués, un modo seguro sin GPU y la opción de copiar todo a la RAM.",
+ "pt": "Sim. Inicie a ISO a partir de um pendrive e o LordOS abre no modo live, sem mexer no seu disco; as mudanças ficam na memória e somem ao desligar. O menu de inicialização também oferece espanhol e português, um modo seguro sem GPU e a opção de copiar tudo para a RAM."
+ }
+ },
+ {
+ "id": "dual-boot",
+ "q": {
+ "en": "Can I install it next to another system?",
+ "es": "¿Puedo instalarla junto a otro sistema?",
+ "pt": "Posso instalar junto com outro sistema?"
+ },
+ "a": {
+ "en": "Not with the ISO's installer yet: it uses the whole disk and erases it, after asking you to confirm. To keep another system, install Debian 13 next to it with Debian's installer and then add LordOS with the one-line installer, or use a separate disk.",
+ "es": "Con el instalador de la ISO, todavía no: usa el disco entero y lo borra, después de pedirte que confirmes. Si querés conservar otro sistema, instalá Debian 13 al lado con el instalador de Debian y después sumá LordOS con el instalador de una línea, o usá otro disco.",
+ "pt": "Com o instalador da ISO, ainda não: ele usa o disco inteiro e o apaga, depois de pedir sua confirmação. Para manter outro sistema, instale o Debian 13 ao lado com o instalador do Debian e depois adicione o LordOS com o instalador de uma linha, ou use outro disco."
+ }
+ },
+ {
+ "id": "debian-one-liner",
+ "q": {
+ "en": "How do I install LordOS on Debian 13?",
+ "es": "¿Cómo instalo LordOS en Debian 13?",
+ "pt": "Como instalo o LordOS no Debian 13?"
+ },
+ "a": {
+ "en": "Run `curl -fsSL https://lordos.org/install.sh | sh` on Debian 13 (amd64 or arm64). The script asks before changing anything, downloads the LordOS package from GitHub Releases, checks its SHA-256 and signature, and installs it with apt, so the dependencies come from your Debian mirrors. Other Debian versions are refused.",
+ "es": "Ejecutá `curl -fsSL https://lordos.org/install.sh | sh` en Debian 13 (amd64 o arm64). El script pregunta antes de cambiar nada, descarga el paquete de LordOS desde GitHub Releases, verifica su SHA-256 y su firma, y lo instala con apt, así que las dependencias salen de tus mirrors de Debian. Con otras versiones de Debian no se instala.",
+ "pt": "Rode `curl -fsSL https://lordos.org/install.sh | sh` no Debian 13 (amd64 ou arm64). O script pergunta antes de mudar qualquer coisa, baixa o pacote do LordOS do GitHub Releases, confere o SHA-256 e a assinatura, e instala com o apt, então as dependências vêm dos seus espelhos do Debian. Outras versões do Debian são recusadas."
+ }
+ },
+ {
+ "id": "what-script-changes",
+ "q": {
+ "en": "What does the Debian installer change?",
+ "es": "¿Qué cambia el instalador para Debian?",
+ "pt": "O que o instalador para Debian muda?"
+ },
+ "a": {
+ "en": "It installs the `lordos` package and a few audio and font packages, creates the login screen's system user, adds your user to groups such as audio and video, and enables the LordOS services. If you agree, it disables your current display manager (GDM, SDDM, LightDM…) for the next boot without removing it. It doesn't touch your network configuration or your home folder, and remote desktop stays off.",
+ "es": "Instala el paquete `lordos` y algunos paquetes de audio y fuentes, crea el usuario de sistema de la pantalla de inicio, suma tu usuario a grupos como audio y video, y habilita los servicios de LordOS. Si aceptás, deshabilita tu gestor de pantalla actual (GDM, SDDM, LightDM…) para el próximo arranque, sin desinstalarlo. No toca tu configuración de red ni tu carpeta personal, y el escritorio remoto queda apagado.",
+ "pt": "Instala o pacote `lordos` e alguns pacotes de áudio e fontes, cria o usuário de sistema da tela de login, adiciona seu usuário a grupos como audio e video, e habilita os serviços do LordOS. Se você aceitar, desativa o seu gerenciador de exibição atual (GDM, SDDM, LightDM…) para a próxima inicialização, sem removê-lo. Não mexe na sua configuração de rede nem na sua pasta pessoal, e o desktop remoto fica desligado."
+ }
+ },
+ {
+ "id": "uninstall",
+ "q": {
+ "en": "How do I uninstall it?",
+ "es": "¿Cómo la desinstalo?",
+ "pt": "Como desinstalo?"
+ },
+ "a": {
+ "en": "On Debian, run `curl -fsSL https://lordos.org/install.sh | sh -s -- --uninstall` (add `--purge` to remove its configuration too). It undoes exactly what the installer recorded and turns your previous display manager back on; your home folder is kept. If you installed from the ISO, LordOS is the whole system, so you'd reinstall another one.",
+ "es": "En Debian, ejecutá `curl -fsSL https://lordos.org/install.sh | sh -s -- --uninstall` (sumá `--purge` para borrar también su configuración). Deshace exactamente lo que el instalador registró y vuelve a activar tu gestor de pantalla anterior; tu carpeta personal queda. Si instalaste desde la ISO, LordOS es todo el sistema, así que tendrías que instalar otro.",
+ "pt": "No Debian, rode `curl -fsSL https://lordos.org/install.sh | sh -s -- --uninstall` (adicione `--purge` para remover também a configuração). Ele desfaz exatamente o que o instalador registrou e reativa o seu gerenciador de exibição anterior; sua pasta pessoal é mantida. Se você instalou pela ISO, o LordOS é o sistema inteiro, então seria preciso instalar outro."
+ }
+ },
+ {
+ "id": "verify-signatures",
+ "q": {
+ "en": "How do I verify a download?",
+ "es": "¿Cómo verifico una descarga?",
+ "pt": "Como verifico um download?"
+ },
+ "a": {
+ "en": "Each release has a `SHA256SUMS` file signed with the LordOS release key (Ed25519, fingerprint `c7155b8e6bbbb180f907381994d06af76d333016cd6f3facf67cadd053ea108e`). Check the signature with OpenSSL and the file with `sha256sum -c`; the exact commands are in the [Security policy](/legal/security/). The Debian installer does this by itself and refuses an invalid signature.",
+ "es": "Cada versión trae un archivo `SHA256SUMS` firmado con la clave de versiones de LordOS (Ed25519, huella `c7155b8e6bbbb180f907381994d06af76d333016cd6f3facf67cadd053ea108e`). Verificá la firma con OpenSSL y el archivo con `sha256sum -c`; los comandos exactos están en la [Política de seguridad](/legal/security/). El instalador para Debian lo hace solo y rechaza una firma inválida.",
+ "pt": "Cada versão traz um arquivo `SHA256SUMS` assinado com a chave de versões do LordOS (Ed25519, impressão digital `c7155b8e6bbbb180f907381994d06af76d333016cd6f3facf67cadd053ea108e`). Confira a assinatura com o OpenSSL e o arquivo com `sha256sum -c`; os comandos exatos estão na [Política de segurança](/legal/security/). O instalador para Debian faz isso sozinho e recusa uma assinatura inválida."
+ }
+ }
+ ]
+ },
+ {
+ "id": "raspberry-pi",
+ "title": {
+ "en": "Raspberry Pi",
+ "es": "Raspberry Pi",
+ "pt": "Raspberry Pi"
+ },
+ "items": [
+ {
+ "id": "which-pi",
+ "q": {
+ "en": "Which Raspberry Pi models are supported?",
+ "es": "¿Qué modelos de Raspberry Pi soporta?",
+ "pt": "Quais modelos de Raspberry Pi são suportados?"
+ },
+ "a": {
+ "en": "Only the Raspberry Pi 5 (4, 8 or 16 GB). The Pi 500 and CM5 may work but aren't tested, and the Pi 4, 400, CM4 and older models aren't supported. The Pi 5 image is still in beta: parts such as HDMI and the desktop session haven't been verified on the board yet.",
+ "es": "Solo la Raspberry Pi 5 (4, 8 o 16 GB). La Pi 500 y la CM5 quizás anden, pero no están probadas, y la Pi 4, 400, CM4 y modelos anteriores no están soportados. La imagen para Pi 5 sigue en beta: partes como el HDMI y la sesión de escritorio todavía no se verificaron en la placa.",
+ "pt": "Só o Raspberry Pi 5 (4, 8 ou 16 GB). O Pi 500 e o CM5 talvez funcionem, mas não foram testados, e o Pi 4, 400, CM4 e modelos anteriores não são suportados. A imagem para o Pi 5 ainda está em beta: partes como o HDMI e a sessão de desktop ainda não foram verificadas na placa."
+ }
+ },
+ {
+ "id": "sd-or-nvme",
+ "q": {
+ "en": "Can I use an SD card or an NVMe drive?",
+ "es": "¿Puedo usar una tarjeta SD o un disco NVMe?",
+ "pt": "Posso usar um cartão SD ou um SSD NVMe?"
+ },
+ "a": {
+ "en": "Both: the same image (`lordos-<version>-rpi5-arm64.img.xz`) is written to an SD card or to an NVMe drive. NVMe on the M.2 HAT+ is recommended for speed; to boot from it first, set the Pi's EEPROM boot order to NVMe.",
+ "es": "Las dos: la misma imagen (`lordos-<versión>-rpi5-arm64.img.xz`) se graba en una tarjeta SD o en un disco NVMe. Por velocidad se recomienda NVMe en el M.2 HAT+; para arrancar primero desde ahí, poné NVMe primero en el orden de arranque de la EEPROM de la Pi.",
+ "pt": "Os dois: a mesma imagem (`lordos-<versão>-rpi5-arm64.img.xz`) é gravada num cartão SD ou num SSD NVMe. Pela velocidade, recomenda-se NVMe no M.2 HAT+; para iniciar primeiro por ele, coloque o NVMe primeiro na ordem de boot da EEPROM do Pi."
+ }
+ },
+ {
+ "id": "pi-fans",
+ "q": {
+ "en": "Does it control the fan? What about the Argon ONE V5 case?",
+ "es": "¿Controla el ventilador? ¿Y la carcasa Argon ONE V5?",
+ "pt": "Ele controla a ventoinha? E o case Argon ONE V5?"
+ },
+ "a": {
+ "en": "Yes. LordOS drives the Pi 5 fan header by temperature, with profiles in Settings → Cooling; an Active Cooler or a fan heatsink is recommended, since without one the Pi slows down when hot. The Argon ONE V5 case's fan uses the same header: choose it in Settings → Cooling → Case and restart, which also enables its front USB ports and audio.",
+ "es": "Sí. LordOS maneja el conector de ventilador de la Pi 5 según la temperatura, con perfiles en Ajustes → Refrigeración; se recomienda un Active Cooler o un disipador con ventilador, porque sin eso la Pi baja la velocidad cuando se calienta. El ventilador de la carcasa Argon ONE V5 usa el mismo conector: elegila en Ajustes → Refrigeración → Caja y reiniciá, y eso también activa sus USB frontales y el audio.",
+ "pt": "Sim. O LordOS controla o conector de ventoinha do Pi 5 pela temperatura, com perfis em Ajustes → Resfriamento; recomenda-se um Active Cooler ou um dissipador com ventoinha, porque sem isso o Pi reduz a velocidade quando esquenta. A ventoinha do case Argon ONE V5 usa o mesmo conector: escolha-o em Ajustes → Resfriamento → Gabinete e reinicie, o que também ativa as USB frontais e o áudio."
+ }
+ },
+ {
+ "id": "switch-files",
+ "q": {
+ "en": "What are the switch files on the boot partition?",
+ "es": "¿Qué son los archivos interruptor de la partición de arranque?",
+ "pt": "O que são os arquivos interruptores da partição de boot?"
+ },
+ "a": {
+ "en": "Files you put on the image's `bootfs` partition before booting: `lordos-user.txt` (copied from `lordos-user.txt.example`) creates your user and can join a Wi-Fi network, an empty `ssh` file turns on the SSH server, and `remote-desktop` turns on LordOS remote desktop. Raspberry Pi Imager's `userconf.txt` also works. Without a user file, LordOS starts in setup mode so you can create the account in Settings → Users.",
+ "es": "Archivos que ponés en la partición `bootfs` de la imagen antes de arrancar: `lordos-user.txt` (copiado de `lordos-user.txt.example`) crea tu usuario y puede conectarse a una red Wi-Fi, un archivo vacío `ssh` enciende el servidor SSH y `remote-desktop` enciende el escritorio remoto de LordOS. También sirve el `userconf.txt` de Raspberry Pi Imager. Sin archivo de usuario, LordOS arranca en modo configuración para que crees la cuenta en Ajustes → Usuarios.",
+ "pt": "Arquivos que você coloca na partição `bootfs` da imagem antes de iniciar: `lordos-user.txt` (copiado de `lordos-user.txt.example`) cria seu usuário e pode conectar a uma rede Wi-Fi, um arquivo vazio `ssh` liga o servidor SSH e `remote-desktop` liga o desktop remoto do LordOS. O `userconf.txt` do Raspberry Pi Imager também funciona. Sem arquivo de usuário, o LordOS inicia no modo de configuração para você criar a conta em Ajustes → Usuários."
+ }
+ }
+ ]
+ },
+ {
+ "id": "apps",
+ "title": {
+ "en": "Apps",
+ "es": "Apps",
+ "pt": "Apps"
+ },
+ "items": [
+ {
+ "id": "included-apps",
+ "q": {
+ "en": "Which apps are included?",
+ "es": "¿Qué apps vienen incluidas?",
+ "pt": "Quais apps vêm incluídos?"
+ },
+ "a": {
+ "en": "More than 35 native apps, among them Files, Settings, Terminal, Text Editor, Mail, Calendar, Contacts, Notes, Reminders, Photos, Player, Camera, Voice Recorder, PDF Viewer, Passwords, Monitor, Store, Disks, Backups, Clock and Calculator. On PCs, Firefox ESR and Chromium come preinstalled. See the [apps page](/apps/).",
+ "es": "Más de 35 apps nativas, entre ellas Archivos, Ajustes, Terminal, Editor de texto, Mail, Calendario, Contactos, Notas, Recordatorios, Fotos, Reproductor, Cámara, Grabadora, Visor de PDF, Contraseñas, Monitor, Tienda, Discos, Copias de seguridad, Reloj y Calculadora. En PC vienen instalados Firefox ESR y Chromium. Mirá la [página de apps](/apps/).",
+ "pt": "Mais de 35 apps nativos, entre eles Arquivos, Ajustes, Terminal, Editor de texto, Mail, Calendário, Contatos, Notas, Lembretes, Fotos, Reprodutor, Câmera, Gravador, Visualizador de PDF, Senhas, Monitor, Loja, Discos, Cópias de segurança, Relógio e Calculadora. No PC, o Firefox ESR e o Chromium vêm pré-instalados. Veja a [página de apps](/apps/)."
+ }
+ },
+ {
+ "id": "linux-apps",
+ "q": {
+ "en": "Can I run regular Linux apps?",
+ "es": "¿Puedo usar apps de Linux comunes?",
+ "pt": "Posso rodar apps Linux comuns?"
+ },
+ "a": {
+ "en": "Yes, apps that speak Wayland: GTK 3 and 4 (GNOME), Qt (KDE), Firefox, Chromium and Electron apps open as normal LordOS windows, with the LordOS frame and theme. Apps that only support X11 don't run yet, because Xwayland isn't available yet.",
+ "es": "Sí, las que hablan Wayland: las apps GTK 3 y 4 (GNOME), Qt (KDE), Firefox, Chromium y Electron se abren como ventanas normales de LordOS, con su marco y su tema. Las apps que solo soportan X11 todavía no funcionan, porque Xwayland todavía no está disponible.",
+ "pt": "Sim, os que falam Wayland: apps GTK 3 e 4 (GNOME), Qt (KDE), Firefox, Chromium e Electron abrem como janelas normais do LordOS, com a moldura e o tema dele. Apps que só suportam X11 ainda não rodam, porque o Xwayland ainda não está disponível."
+ }
+ },
+ {
+ "id": "flatpak",
+ "q": {
+ "en": "Does it support Flatpak?",
+ "es": "¿Soporta Flatpak?",
+ "pt": "Tem suporte a Flatpak?"
+ },
+ "a": {
+ "en": "Not yet: LordOS doesn't integrate Flatpak. The Store installs Debian packages and LordOS `.lpk` apps, and isolated apps use LordOS's own sandbox.",
+ "es": "Todavía no: LordOS no integra Flatpak. La Tienda instala paquetes de Debian y apps `.lpk` de LordOS, y las apps aisladas usan el sandbox propio de LordOS.",
+ "pt": "Ainda não: o LordOS não integra o Flatpak. A Loja instala pacotes do Debian e apps `.lpk` do LordOS, e os apps isolados usam o sandbox próprio do LordOS."
+ }
+ },
+ {
+ "id": "games",
+ "q": {
+ "en": "Can I play games?",
+ "es": "¿Puedo jugar?",
+ "pt": "Posso jogar?"
+ },
+ "a": {
+ "en": "Wayland games can run with GPU acceleration: LordOS supports fullscreen, relative pointer and pointer locking, which games need, and Neverball has been tested. Games that only use X11 need Xwayland, which isn't available yet, so many games and launchers won't start for now.",
+ "es": "Los juegos para Wayland pueden andar con aceleración por GPU: LordOS soporta pantalla completa, puntero relativo y bloqueo del puntero, que los juegos necesitan, y se probó Neverball. Los juegos que solo usan X11 necesitan Xwayland, que todavía no está disponible, así que por ahora muchos juegos y lanzadores no arrancan.",
+ "pt": "Jogos para Wayland podem rodar com aceleração por GPU: o LordOS suporta tela cheia, ponteiro relativo e travamento do ponteiro, que os jogos precisam, e o Neverball foi testado. Jogos que só usam X11 precisam do Xwayland, que ainda não está disponível, então por enquanto muitos jogos e launchers não abrem."
+ }
+ },
+ {
+ "id": "webassembly",
+ "q": {
+ "en": "What are WebAssembly apps?",
+ "es": "¿Qué son las apps WebAssembly?",
+ "pt": "O que são apps WebAssembly?"
+ },
+ "a": {
+ "en": "LordOS has its own WebAssembly 2.0 interpreter (without SIMD) that `.lpk` apps can use to run code compiled from C, Rust or other languages. A WebAssembly module has no access to files, the network or the system unless its app passes them explicitly.",
+ "es": "LordOS tiene su propio intérprete de WebAssembly 2.0 (sin SIMD) que las apps `.lpk` pueden usar para correr código compilado desde C, Rust u otros lenguajes. Un módulo WebAssembly no tiene acceso a archivos, red ni sistema salvo que su app se los pase explícitamente.",
+ "pt": "O LordOS tem seu próprio interpretador de WebAssembly 2.0 (sem SIMD) que os apps `.lpk` podem usar para rodar código compilado de C, Rust ou outras linguagens. Um módulo WebAssembly não tem acesso a arquivos, rede nem sistema, a menos que o app os passe explicitamente."
+ }
+ },
+ {
+ "id": "store",
+ "q": {
+ "en": "How does the Store work?",
+ "es": "¿Cómo funciona la Tienda?",
+ "pt": "Como a Loja funciona?"
+ },
+ "a": {
+ "en": "The Store installs Debian packages from your apt sources with LordOS's own package engine, which checks Debian's signatures and shows you the plan (what is installed, upgraded or removed, and how much is downloaded) before changing anything. It also installs `.lpk` apps and local `.deb` files. Its package lists are refreshed only when you press Check for updates.",
+ "es": "La Tienda instala paquetes de Debian desde tus fuentes de apt con el motor de paquetes propio de LordOS, que verifica las firmas de Debian y te muestra el plan (qué se instala, actualiza o quita, y cuánto se descarga) antes de cambiar nada. También instala apps `.lpk` y archivos `.deb` locales. Las listas de paquetes se actualizan solo cuando tocás Buscar actualizaciones.",
+ "pt": "A Loja instala pacotes do Debian a partir das suas fontes do apt com o motor de pacotes próprio do LordOS, que confere as assinaturas do Debian e mostra o plano (o que é instalado, atualizado ou removido, e quanto é baixado) antes de mudar qualquer coisa. Ela também instala apps `.lpk` e arquivos `.deb` locais. As listas de pacotes só são atualizadas quando você toca em Procurar atualizações."
+ }
+ },
+ {
+ "id": "lpk-apps",
+ "q": {
+ "en": "What is an .lpk app?",
+ "es": "¿Qué es una app .lpk?",
+ "pt": "O que é um app .lpk?"
+ },
+ "a": {
+ "en": "A `.lpk` is the package format for LordOS native apps: a compressed archive with a manifest, the app's code, its icon and translations. It installs into your home folder without root, runs in its own isolated process and can be signed so you know who made it.",
+ "es": "Un `.lpk` es el formato de paquete de las apps nativas de LordOS: un archivo comprimido con un manifiesto, el código de la app, su ícono y sus traducciones. Se instala en tu carpeta personal sin root, corre en su propio proceso aislado y puede estar firmado para que sepas quién lo hizo.",
+ "pt": "Um `.lpk` é o formato de pacote dos apps nativos do LordOS: um arquivo compactado com um manifesto, o código do app, o ícone e as traduções. Ele é instalado na sua pasta pessoal sem root, roda no próprio processo isolado e pode ser assinado para você saber quem o fez."
+ }
+ }
+ ]
+ },
+ {
+ "id": "privacy-security",
+ "title": {
+ "en": "Privacy and security",
+ "es": "Privacidad y seguridad",
+ "pt": "Privacidade e segurança"
+ },
+ "items": [
+ {
+ "id": "telemetry",
+ "q": {
+ "en": "Does LordOS collect telemetry?",
+ "es": "¿LordOS manda telemetría?",
+ "pt": "O LordOS coleta telemetria?"
+ },
+ "a": {
+ "en": "No. There are no usage statistics, crash reports, device IDs or accounts, and nothing is sent to us. By default LordOS only uses DHCP and DNS on your network, network time and local-network discovery; everything else happens when you ask for it. The full list is in the [Privacy policy](/legal/privacy/).",
+ "es": "No. No hay estadísticas de uso, reportes de fallas, identificadores del equipo ni cuentas, y no se nos envía nada. De fábrica, LordOS solo usa DHCP y DNS en tu red, la hora por red y el descubrimiento en la red local; todo lo demás pasa cuando vos lo pedís. La lista completa está en la [Política de privacidad](/legal/privacy/).",
+ "pt": "Não. Não há estatísticas de uso, relatórios de falhas, identificadores do aparelho nem contas, e nada é enviado para nós. Por padrão, o LordOS só usa DHCP e DNS na sua rede, a hora pela rede e a descoberta na rede local; todo o resto acontece quando você pede. A lista completa está na [Política de privacidade](/legal/privacy/)."
+ }
+ },
+ {
+ "id": "sandbox",
+ "q": {
+ "en": "Which apps are sandboxed?",
+ "es": "¿Qué apps están aisladas?",
+ "pt": "Quais apps ficam isolados?"
+ },
+ "a": {
+ "en": "Every third-party `.lpk` app runs in its own process, isolated with LordOS's own sandbox (Landlock, seccomp, cgroups and no privileges), and reaches the system only through a broker that checks its permissions. Passwords and the helpers that decode mail, documents and media are isolated too. Regular Linux apps (GTK, Qt, browsers) aren't sandboxed, but the per-app firewall applies to them.",
+ "es": "Cada app `.lpk` de terceros corre en su propio proceso, aislada con el sandbox propio de LordOS (Landlock, seccomp, cgroups y sin privilegios), y llega al sistema solo a través de un intermediario que revisa sus permisos. Contraseñas y los procesos que decodifican correo, documentos y multimedia también están aislados. Las apps de Linux comunes (GTK, Qt, navegadores) no están aisladas, pero el firewall por app sí se les aplica.",
+ "pt": "Cada app `.lpk` de terceiros roda no próprio processo, isolado com o sandbox próprio do LordOS (Landlock, seccomp, cgroups e sem privilégios), e só chega ao sistema por um intermediário que confere as permissões. O Senhas e os processos que decodificam e-mail, documentos e mídia também são isolados. Apps Linux comuns (GTK, Qt, navegadores) não ficam isolados, mas o firewall por app vale para eles."
+ }
+ },
+ {
+ "id": "permissions",
+ "q": {
+ "en": "How do app permissions work?",
+ "es": "¿Cómo funcionan los permisos de las apps?",
+ "pt": "Como funcionam as permissões dos apps?"
+ },
+ "a": {
+ "en": "The first time an isolated app wants your files, camera, microphone, screen, network, Bluetooth or USB, the system asks you with a prompt the app can't fake. You can review and change every answer in Settings → Privacy, and revoking a permission takes effect at once. A green dot shows the camera is on and an orange dot the microphone.",
+ "es": "La primera vez que una app aislada quiere tus archivos, la cámara, el micrófono, la pantalla, la red, Bluetooth o USB, el sistema te pregunta con un aviso que la app no puede falsificar. Podés revisar y cambiar cada respuesta en Ajustes → Privacidad, y quitar un permiso tiene efecto al instante. Un punto verde avisa que la cámara está encendida y uno naranja, el micrófono.",
+ "pt": "Na primeira vez que um app isolado quer seus arquivos, a câmera, o microfone, a tela, a rede, o Bluetooth ou o USB, o sistema pergunta com um aviso que o app não consegue falsificar. Você pode revisar e mudar cada resposta em Ajustes → Privacidade, e revogar uma permissão vale na hora. Um ponto verde indica a câmera ligada e um laranja, o microfone."
+ }
+ },
+ {
+ "id": "firewall",
+ "q": {
+ "en": "Is there a per-app firewall?",
+ "es": "¿Hay un firewall por app?",
+ "pt": "Existe um firewall por app?"
+ },
+ "a": {
+ "en": "Yes. `lord-netperm` enforces per-app network rules in the kernel for LordOS apps, `.lpk` apps and Linux apps alike: allow or block, local network or internet, domains, ports and time limits. Monitor shows each app's connections on a world map and lets you block an app with one switch. An \"ask me\" mode is still to come.",
+ "es": "Sí. `lord-netperm` aplica reglas de red por app en el kernel, tanto para las apps de LordOS como para las `.lpk` y las de Linux: permitir o bloquear, red local o internet, dominios, puertos y límites de tiempo. Monitor muestra las conexiones de cada app en un mapa del mundo y te deja bloquear una app con un interruptor. El modo \"preguntarme\" todavía no está.",
+ "pt": "Sim. O `lord-netperm` aplica regras de rede por app no kernel, para os apps do LordOS, os `.lpk` e os apps Linux: permitir ou bloquear, rede local ou internet, domínios, portas e limites de tempo. O Monitor mostra as conexões de cada app num mapa-múndi e deixa bloquear um app com um interruptor. O modo \"perguntar\" ainda está por vir."
+ }
+ },
+ {
+ "id": "remote-desktop",
+ "q": {
+ "en": "Is remote desktop on by default?",
+ "es": "¿El escritorio remoto viene encendido?",
+ "pt": "O desktop remoto vem ligado?"
+ },
+ "a": {
+ "en": "No. It's off by default and port 5673 stays closed until you turn it on in Settings → Sharing. Then you open `https://<the computer's address>:5673` in a browser on your local network and log in with your account; the connection is encrypted with TLS. To reach it from the internet, use a VPN rather than opening the port.",
+ "es": "No. Viene apagado y el puerto 5673 queda cerrado hasta que lo encendés en Ajustes → Compartir. Después abrís `https://<la dirección del equipo>:5673` en un navegador de tu red local y entrás con tu cuenta; la conexión va cifrada con TLS. Para llegar desde internet, usá una VPN en vez de abrir el puerto.",
+ "pt": "Não. Ele vem desligado e a porta 5673 fica fechada até você ligá-lo em Ajustes → Compartilhar. Depois você abre `https://<o endereço do computador>:5673` num navegador da sua rede local e entra com sua conta; a conexão é criptografada com TLS. Para acessar pela internet, use uma VPN em vez de abrir a porta."
+ }
+ },
+ {
+ "id": "passwords",
+ "q": {
+ "en": "How are my passwords stored?",
+ "es": "¿Cómo se guardan mis contraseñas?",
+ "pt": "Como minhas senhas são guardadas?"
+ },
+ "a": {
+ "en": "In an encrypted vault (XChaCha20-Poly1305 with an Argon2id key) handled by `lord-vault`, a process with no network access. The Passwords app keeps logins, 2FA codes, cards and notes, can unlock with a FIDO2 security key and imports KeePass files; Wi-Fi and VPN passwords and browsers' saved secrets use the same vault. The breached-password check works offline.",
+ "es": "En una bóveda cifrada (XChaCha20-Poly1305 con clave Argon2id) que maneja `lord-vault`, un proceso sin acceso a la red. La app Contraseñas guarda accesos, códigos 2FA, tarjetas y notas, se puede desbloquear con una llave de seguridad FIDO2 e importa archivos de KeePass; las contraseñas de Wi-Fi y VPN y los secretos que guardan los navegadores usan la misma bóveda. La revisión de contraseñas filtradas funciona sin conexión.",
+ "pt": "Num cofre criptografado (XChaCha20-Poly1305 com chave Argon2id) controlado pelo `lord-vault`, um processo sem acesso à rede. O app Senhas guarda logins, códigos 2FA, cartões e notas, pode ser desbloqueado com uma chave de segurança FIDO2 e importa arquivos do KeePass; as senhas de Wi-Fi e VPN e os segredos salvos pelos navegadores usam o mesmo cofre. A verificação de senhas vazadas funciona offline."
+ }
+ },
+ {
+ "id": "signed-packages",
+ "q": {
+ "en": "Are packages signed?",
+ "es": "¿Los paquetes están firmados?",
+ "pt": "Os pacotes são assinados?"
+ },
+ "a": {
+ "en": "Yes. Debian packages are checked against Debian's signed package lists and their SHA-256. `.lpk` apps can be signed with Ed25519, and the Store shows whether one comes from LordOS, a verified author, a named signer or nobody, and warns if it was modified. LordOS's own releases are signed with the release key.",
+ "es": "Sí. Los paquetes de Debian se verifican contra las listas firmadas de Debian y su SHA-256. Las apps `.lpk` pueden estar firmadas con Ed25519, y la Tienda muestra si vienen de LordOS, de un autor verificado, de un firmante con nombre o de nadie, y avisa si fueron modificadas. Las versiones de LordOS se firman con la clave de versiones.",
+ "pt": "Sim. Os pacotes do Debian são conferidos contra as listas assinadas do Debian e o SHA-256. Os apps `.lpk` podem ser assinados com Ed25519, e a Loja mostra se vêm do LordOS, de um autor verificado, de um assinante identificado ou de ninguém, e avisa se foram modificados. As versões do LordOS são assinadas com a chave de versões."
+ }
+ },
+ {
+ "id": "report-vulnerability",
+ "q": {
+ "en": "How do I report a security problem?",
+ "es": "¿Cómo reporto un problema de seguridad?",
+ "pt": "Como relato um problema de segurança?"
+ },
+ "a": {
+ "en": "Write privately to [[SECURITY_EMAIL]] and don't publish details until there is a fix. The [Security policy](/legal/security/) explains the scope, the safe harbour and our response times.",
+ "es": "Escribinos en privado a [[SECURITY_EMAIL]] y no publiques detalles hasta que haya un arreglo. La [Política de seguridad](/legal/security/) explica el alcance, el puerto seguro y nuestros tiempos de respuesta.",
+ "pt": "Escreva em privado para [[SECURITY_EMAIL]] e não publique detalhes até haver uma correção. A [Política de segurança](/legal/security/) explica o escopo, o porto seguro e nossos prazos de resposta."
+ }
+ }
+ ]
+ },
+ {
+ "id": "hardware",
+ "title": {
+ "en": "Hardware",
+ "es": "Hardware",
+ "pt": "Hardware"
+ },
+ "items": [
+ {
+ "id": "gpu",
+ "q": {
+ "en": "Which graphics cards work?",
+ "es": "¿Qué placas de video funcionan?",
+ "pt": "Quais placas de vídeo funcionam?"
+ },
+ "a": {
+ "en": "LordOS uses Debian's Mesa drivers for AMD, Intel and NVIDIA (radeonsi, iris, nouveau and their Vulkan drivers), and falls back to drawing with the CPU when there is no usable GPU. If graphics fail, choose the safe mode in the boot menu. Testing on real AMD and NVIDIA cards is still in progress.",
+ "es": "LordOS usa los drivers Mesa de Debian para AMD, Intel y NVIDIA (radeonsi, iris, nouveau y sus drivers Vulkan), y si no hay una GPU que sirva dibuja con la CPU. Si falla el video, elegí el modo seguro en el menú de arranque. Las pruebas en placas AMD y NVIDIA reales siguen en curso.",
+ "pt": "O LordOS usa os drivers Mesa do Debian para AMD, Intel e NVIDIA (radeonsi, iris, nouveau e os drivers Vulkan deles), e quando não há uma GPU utilizável desenha com a CPU. Se o vídeo falhar, escolha o modo seguro no menu de inicialização. Os testes em placas AMD e NVIDIA reais ainda estão em andamento."
+ }
+ },
+ {
+ "id": "nvidia",
+ "q": {
+ "en": "Does it work with NVIDIA cards?",
+ "es": "¿Funciona con placas NVIDIA?",
+ "pt": "Funciona com placas NVIDIA?"
+ },
+ "a": {
+ "en": "NVIDIA cards use Mesa's open drivers (nouveau, and NVK for Vulkan), which are included. It hasn't been tested on real NVIDIA hardware yet, and NVIDIA's proprietary driver isn't supported yet. If the desktop doesn't start, the safe mode uses the CPU.",
+ "es": "Las placas NVIDIA usan los drivers abiertos de Mesa (nouveau, y NVK para Vulkan), que vienen incluidos. Todavía no se probó en hardware NVIDIA real, y el driver propietario de NVIDIA todavía no está soportado. Si el escritorio no arranca, el modo seguro usa la CPU.",
+ "pt": "As placas NVIDIA usam os drivers abertos do Mesa (nouveau, e NVK para Vulkan), que vêm incluídos. Ainda não foi testado em hardware NVIDIA real, e o driver proprietário da NVIDIA ainda não é suportado. Se o desktop não abrir, o modo seguro usa a CPU."
+ }
+ },
+ {
+ "id": "multi-monitor-hidpi",
+ "q": {
+ "en": "Does it support several monitors and HiDPI screens?",
+ "es": "¿Soporta varios monitores y pantallas HiDPI?",
+ "pt": "Suporta vários monitores e telas HiDPI?"
+ },
+ "a": {
+ "en": "Yes. In Settings → Displays you can extend or mirror screens, arrange and rotate them, and set each one's scale (100, 125, 150, 175 or 200 %), even mixing different scales. GTK 4, Qt 6 and Chromium apps draw sharply at fractional scales.",
+ "es": "Sí. En Ajustes → Pantallas podés extender o duplicar pantallas, acomodarlas y rotarlas, y elegir la escala de cada una (100, 125, 150, 175 o 200 %), incluso mezclando escalas distintas. Las apps GTK 4, Qt 6 y Chromium se ven nítidas con escalas fraccionarias.",
+ "pt": "Sim. Em Ajustes → Telas você pode estender ou espelhar telas, organizá-las e girá-las, e definir a escala de cada uma (100, 125, 150, 175 ou 200 %), até misturando escalas diferentes. Apps GTK 4, Qt 6 e Chromium ficam nítidos em escalas fracionárias."
+ }
+ },
+ {
+ "id": "touchpad",
+ "q": {
+ "en": "Do touchpad gestures work?",
+ "es": "¿Funcionan los gestos del touchpad?",
+ "pt": "Os gestos do touchpad funcionam?"
+ },
+ "a": {
+ "en": "Yes. LordOS has its own touchpad driver with tap to click, two-finger click, natural and inertial scrolling, pinch to zoom and three-finger swipes, set up in Settings → Trackpad. Touchscreens work too.",
+ "es": "Sí. LordOS tiene su propio driver de touchpad con tocar para hacer clic, clic con dos dedos, desplazamiento natural y con inercia, pellizcar para hacer zoom y deslizar con tres dedos, que configurás en Ajustes → Trackpad. Las pantallas táctiles también funcionan.",
+ "pt": "Sim. O LordOS tem seu próprio driver de touchpad com tocar para clicar, clique com dois dedos, rolagem natural e com inércia, pinçar para zoom e deslizar com três dedos, configurados em Ajustes → Trackpad. Telas sensíveis ao toque também funcionam."
+ }
+ },
+ {
+ "id": "printers-scanners",
+ "q": {
+ "en": "Can I use printers and scanners?",
+ "es": "¿Puedo usar impresoras y escáneres?",
+ "pt": "Posso usar impressoras e scanners?"
+ },
+ "a": {
+ "en": "Yes, driverless ones: printers that support IPP Everywhere (through CUPS) and scanners that support eSCL, found automatically on your network in Settings → Printers & Scanners. Printers that need a special driver aren't supported yet, and testing with real printers is still pending.",
+ "es": "Sí, las que no necesitan driver: impresoras con IPP Everywhere (a través de CUPS) y escáneres con eSCL, que aparecen solos en tu red en Ajustes → Impresoras y escáneres. Las impresoras que necesitan un driver especial todavía no están soportadas, y las pruebas con impresoras reales siguen pendientes.",
+ "pt": "Sim, as que não precisam de driver: impressoras com IPP Everywhere (via CUPS) e scanners com eSCL, encontrados sozinhos na sua rede em Ajustes → Impressoras e scanners. Impressoras que precisam de driver especial ainda não são suportadas, e os testes com impressoras reais ainda estão pendentes."
+ }
+ },
+ {
+ "id": "bluetooth",
+ "q": {
+ "en": "Does Bluetooth work?",
+ "es": "¿Funciona el Bluetooth?",
+ "pt": "O Bluetooth funciona?"
+ },
+ "a": {
+ "en": "Yes. Settings → Bluetooth finds, pairs and connects devices through BlueZ, and Bluetooth headphones and speakers play through PipeWire.",
+ "es": "Sí. Ajustes → Bluetooth busca, empareja y conecta dispositivos a través de BlueZ, y los auriculares y parlantes Bluetooth suenan a través de PipeWire.",
+ "pt": "Sim. Ajustes → Bluetooth encontra, pareia e conecta dispositivos via BlueZ, e fones e caixas de som Bluetooth tocam pelo PipeWire."
+ }
+ },
+ {
+ "id": "pc-fans",
+ "q": {
+ "en": "Can it control the fans on my PC?",
+ "es": "¿Puede controlar los ventiladores de mi PC?",
+ "pt": "Ele controla as ventoinhas do meu PC?"
+ },
+ "a": {
+ "en": "Only on desktop motherboards with a known fan controller chip, and only if you choose a profile other than System in Settings → Cooling; by default the firmware stays in control. Laptop and graphics card fans are never touched. PC fan control hasn't been tried on a real motherboard yet.",
+ "es": "Solo en motherboards de escritorio con un chip controlador de ventiladores conocido, y solo si elegís un perfil distinto de Sistema en Ajustes → Refrigeración; de fábrica manda el firmware. Los ventiladores de notebooks y placas de video nunca se tocan. El control de ventiladores en PC todavía no se probó en una motherboard real.",
+ "pt": "Só em placas-mãe de desktop com um chip controlador de ventoinhas conhecido, e só se você escolher um perfil diferente de Sistema em Ajustes → Resfriamento; por padrão o firmware continua no controle. As ventoinhas de notebooks e placas de vídeo nunca são tocadas. O controle de ventoinhas no PC ainda não foi testado numa placa-mãe real."
+ }
+ }
+ ]
+ },
+ {
+ "id": "languages-accessibility",
+ "title": {
+ "en": "Languages and accessibility",
+ "es": "Idiomas y accesibilidad",
+ "pt": "Idiomas e acessibilidade"
+ },
+ "items": [
+ {
+ "id": "languages",
+ "q": {
+ "en": "Which languages does LordOS speak?",
+ "es": "¿En qué idiomas está LordOS?",
+ "pt": "Em quais idiomas o LordOS está?"
+ },
+ "a": {
+ "en": "English (the default), Spanish and Portuguese are built in, and you can pick one on the boot menu or in Settings → Language & Region. Other languages are added as language packs: anyone can make one from a set of translation files.",
+ "es": "Inglés (el predeterminado), español y portugués vienen incluidos, y podés elegir uno en el menú de arranque o en Ajustes → Idioma y región. Otros idiomas se suman como paquetes de idioma: cualquiera puede armar uno a partir de un conjunto de archivos de traducción.",
+ "pt": "Inglês (o padrão), espanhol e português vêm incluídos, e você pode escolher um no menu de inicialização ou em Ajustes → Idioma e região. Outros idiomas entram como pacotes de idioma: qualquer pessoa pode montar um a partir de um conjunto de arquivos de tradução."
+ }
+ },
+ {
+ "id": "scripts-input",
+ "q": {
+ "en": "Does it handle Arabic, Hebrew, Asian scripts and input methods?",
+ "es": "¿Maneja árabe, hebreo, escrituras asiáticas y métodos de entrada?",
+ "pt": "Ele lida com árabe, hebraico, escritas asiáticas e métodos de entrada?"
+ },
+ "a": {
+ "en": "Yes. Text layout supports bidirectional text with a mirrored right-to-left interface, Arabic and Indic shaping, Thai, and Chinese, Japanese and Korean. Built-in input methods cover Korean, Japanese (kana and SKK) and Chinese (pinyin), along with every standard keyboard layout.",
+ "es": "Sí. El texto soporta escritura bidireccional con la interfaz espejada de derecha a izquierda, el modelado del árabe y de las escrituras índicas, el tailandés y el chino, japonés y coreano. Los métodos de entrada incluidos cubren coreano, japonés (kana y SKK) y chino (pinyin), además de todas las distribuciones de teclado estándar.",
+ "pt": "Sim. O texto suporta escrita bidirecional com a interface espelhada da direita para a esquerda, a modelagem do árabe e das escritas índicas, o tailandês e o chinês, japonês e coreano. Os métodos de entrada incluídos cobrem coreano, japonês (kana e SKK) e chinês (pinyin), além de todos os layouts de teclado padrão."
+ }
+ },
+ {
+ "id": "accessibility",
+ "q": {
+ "en": "Is LordOS accessible?",
+ "es": "¿LordOS es accesible?",
+ "pt": "O LordOS é acessível?"
+ },
+ "a": {
+ "en": "Partly, for now. There is a Reduce motion setting, per-display scaling and keyboard shortcuts, but a screen reader, screen zoom and a high-contrast theme are not available yet; they are on the roadmap. The website's accessibility is described in the [Accessibility statement](/legal/accessibility/).",
+ "es": "En parte, por ahora. Hay una opción para reducir el movimiento, escala por pantalla y atajos de teclado, pero un lector de pantalla, la lupa y un tema de alto contraste todavía no están; están en la hoja de ruta. La accesibilidad del sitio está descrita en la [Declaración de accesibilidad](/legal/accessibility/).",
+ "pt": "Em parte, por enquanto. Há uma opção para reduzir o movimento, escala por tela e atalhos de teclado, mas um leitor de tela, a lupa e um tema de alto contraste ainda não estão disponíveis; estão no roteiro. A acessibilidade do site está descrita na [Declaração de acessibilidade](/legal/accessibility/)."
+ }
+ }
+ ]
+ },
+ {
+ "id": "updates",
+ "title": {
+ "en": "Updates",
+ "es": "Actualizaciones",
+ "pt": "Atualizações"
+ },
+ "items": [
+ {
+ "id": "how-updates",
+ "q": {
+ "en": "How do I keep LordOS up to date?",
+ "es": "¿Cómo mantengo LordOS actualizada?",
+ "pt": "Como mantenho o LordOS atualizado?"
+ },
+ "a": {
+ "en": "Open the Store's Updates tab and press Check for updates: it refreshes Debian's package lists, shows what will change and upgrades everything together, including Debian's security updates. Nothing is checked or downloaded automatically. You can still use `apt` in the Terminal if you prefer.",
+ "es": "Abrí la pestaña Actualizaciones de la Tienda y tocá Buscar actualizaciones: refresca las listas de paquetes de Debian, te muestra qué va a cambiar y actualiza todo junto, incluidas las actualizaciones de seguridad de Debian. Nada se revisa ni se descarga solo. Si preferís, podés seguir usando `apt` en la Terminal.",
+ "pt": "Abra a aba Atualizações da Loja e toque em Procurar atualizações: ela atualiza as listas de pacotes do Debian, mostra o que vai mudar e atualiza tudo junto, incluindo as atualizações de segurança do Debian. Nada é verificado nem baixado automaticamente. Se preferir, você ainda pode usar o `apt` no Terminal."
+ }
+ },
+ {
+ "id": "new-versions",
+ "q": {
+ "en": "How do I get a new LordOS version?",
+ "es": "¿Cómo paso a una versión nueva de LordOS?",
+ "pt": "Como pego uma versão nova do LordOS?"
+ },
+ "a": {
+ "en": "New versions are published on [GitHub Releases](https://github.com/lordbasex/LordOS/releases) as a `.deb` package, an ISO and a Raspberry Pi image. On Debian, running the one-line installer again upgrades LordOS; you can also install a downloaded `.deb` from the Store. A built-in updater for LordOS itself is not available yet.",
+ "es": "Las versiones nuevas se publican en [GitHub Releases](https://github.com/lordbasex/LordOS/releases) como paquete `.deb`, ISO e imagen para Raspberry Pi. En Debian, volver a ejecutar el instalador de una línea actualiza LordOS; también podés instalar un `.deb` descargado desde la Tienda. Un actualizador propio de LordOS todavía no está disponible.",
+ "pt": "As versões novas são publicadas no [GitHub Releases](https://github.com/lordbasex/LordOS/releases) como pacote `.deb`, ISO e imagem para Raspberry Pi. No Debian, rodar de novo o instalador de uma linha atualiza o LordOS; você também pode instalar um `.deb` baixado pela Loja. Um atualizador próprio do LordOS ainda não está disponível."
+ }
+ }
+ ]
+ },
+ {
+ "id": "contributing-support",
+ "title": {
+ "en": "Contributing and support",
+ "es": "Contribuir y soporte",
+ "pt": "Contribuir e suporte"
+ },
+ "items": [
+ {
+ "id": "report-bug",
+ "q": {
+ "en": "How do I report a bug?",
+ "es": "¿Cómo reporto un error?",
+ "pt": "Como relato um bug?"
+ },
+ "a": {
+ "en": "Once the repository is public, open an issue on [GitHub](https://github.com/lordbasex/LordOS/issues) with your LordOS version (from the About LordOS app), your hardware and the steps to reproduce it. Until then, write to [[CONTACT_EMAIL]]. Security problems go privately to [[SECURITY_EMAIL]].",
+ "es": "Cuando el repositorio sea público, abrí un issue en [GitHub](https://github.com/lordbasex/LordOS/issues) con tu versión de LordOS (la ves en la app Acerca de LordOS), tu hardware y los pasos para reproducirlo. Mientras tanto, escribinos a [[CONTACT_EMAIL]]. Los problemas de seguridad van en privado a [[SECURITY_EMAIL]].",
+ "pt": "Quando o repositório for público, abra uma issue no [GitHub](https://github.com/lordbasex/LordOS/issues) com sua versão do LordOS (no app Sobre o LordOS), seu hardware e os passos para reproduzir. Até lá, escreva para [[CONTACT_EMAIL]]. Problemas de segurança vão em privado para [[SECURITY_EMAIL]]."
+ }
+ },
+ {
+ "id": "contribute",
+ "q": {
+ "en": "Can I contribute code or translations?",
+ "es": "¿Puedo aportar código o traducciones?",
+ "pt": "Posso contribuir com código ou traduções?"
+ },
+ "a": {
+ "en": "We'd love that. Contribution guidelines will be published together with the public repository; until then, write to [[CONTACT_EMAIL]]. Translations can already be made as LordOS language packs.",
+ "es": "Nos encantaría. Las pautas para contribuir se van a publicar junto con el repositorio público; mientras tanto, escribinos a [[CONTACT_EMAIL]]. Las traducciones ya se pueden hacer como paquetes de idioma de LordOS.",
+ "pt": "Adoraríamos. As diretrizes de contribuição serão publicadas junto com o repositório público; até lá, escreva para [[CONTACT_EMAIL]]. As traduções já podem ser feitas como pacotes de idioma do LordOS."
+ }
+ },
+ {
+ "id": "donations",
+ "q": {
+ "en": "How can I donate, and what do donations fund?",
+ "es": "¿Cómo puedo donar y qué financian las donaciones?",
+ "pt": "Como posso doar e o que as doações financiam?"
+ },
+ "a": {
+ "en": "From the [Support section](/#support), with PayPal or Mercado Pago (Binance is coming). Donations help us keep working on LordOS: development time, testing on real hardware and hosting. They are voluntary gifts, not purchases; see the [Donation terms](/legal/donations/).",
+ "es": "Desde la [sección Apoyar](/#support), con PayPal o Mercado Pago (Binance está por llegar). Las donaciones nos ayudan a seguir trabajando en LordOS: tiempo de desarrollo, pruebas en hardware real y hosting. Son aportes voluntarios, no compras; mirá los [Términos de las donaciones](/legal/donations/).",
+ "pt": "Pela [seção Apoiar](/#support), com PayPal ou Mercado Pago (Binance vem aí). As doações nos ajudam a continuar trabalhando no LordOS: tempo de desenvolvimento, testes em hardware real e hospedagem. São contribuições voluntárias, não compras; veja os [Termos das doações](/legal/donations/)."
+ }
+ },
+ {
+ "id": "contact",
+ "q": {
+ "en": "How do I contact the team?",
+ "es": "¿Cómo me contacto con el equipo?",
+ "pt": "Como entro em contato com a equipe?"
+ },
+ "a": {
+ "en": "Write to [[CONTACT_EMAIL]]. We answer in English, Spanish and Portuguese.",
+ "es": "Escribinos a [[CONTACT_EMAIL]]. Respondemos en inglés, español y portugués.",
+ "pt": "Escreva para [[CONTACT_EMAIL]]. Respondemos em inglês, espanhol e português."
+ }
+ },
+ {
+ "id": "use-logo",
+ "q": {
+ "en": "Can I use the LordOS logo?",
+ "es": "¿Puedo usar el logo de LordOS?",
+ "pt": "Posso usar o logo do LordOS?"
+ },
+ "a": {
+ "en": "Yes, to refer to the project, link to it or write about it, using the unmodified files from the [brand kit](https://github.com/lordbasex/LordOS/blob/main/docs/LORDOS-BRAND.md). Don't modify the logo or Lumo or suggest we endorse you, and a modified distribution or fork needs its own name and logo. The details are in the [Trademark policy](/legal/trademark/).",
+ "es": "Sí, para mencionar el proyecto, enlazarlo o escribir sobre él, usando los archivos sin modificar del [kit de marca](https://github.com/lordbasex/LordOS/blob/main/docs/LORDOS-BRAND.md). No modifiques el logo ni a Lumo ni des a entender que te respaldamos, y una distribución modificada o un fork necesita su propio nombre y logo. Los detalles están en la [Política de marca](/legal/trademark/).",
+ "pt": "Sim, para mencionar o projeto, colocar um link ou escrever sobre ele, usando os arquivos sem modificação do [kit de marca](https://github.com/lordbasex/LordOS/blob/main/docs/LORDOS-BRAND.md). Não modifique o logo nem o Lumo nem dê a entender que apoiamos você, e uma distribuição modificada ou um fork precisa de nome e logo próprios. Os detalhes estão na [Política de marca](/legal/trademark/)."
+ }
+ }
+ ]
+ }
+ ]
+}
diff --git a/web/content/features/linux-apps.en.md b/web/content/features/linux-apps.en.md
new file mode 100644
index 0000000..63cfde8
--- /dev/null
+++ b/web/content/features/linux-apps.en.md
@@ -0,0 +1,80 @@
+## The short version
+
+LordOS has a desktop of its own, but it is still Debian underneath. The tens of thousands of programs in Debian's archive are available, and graphical apps built with GTK or Qt, plus browsers like Chromium and Firefox, open as LordOS windows, with the same frame, the same Dock and the same light or dark mode as the native apps.
+
+[[shot:0]]
+
+The trick is a common language. Linux apps speak **Wayland**, a protocol for "here is my window, here are my pixels, send me the mouse and the keyboard". LordOS's display server speaks it too. So an app that knows nothing about LordOS can still live on its desktop, the way a traveller who speaks the local language doesn't need a guide.
+
+[[diagram:linux]]
+
+## Installing them
+
+- **The Store** shows Debian's apps by category, with search, and shows you a plan (what will be installed or removed) before doing anything. It also installs LordOS's own `.lpk` apps and local `.deb` files.
+- **LordOS's own package engine** reads your apt sources, verifies the signed indexes with its own OpenPGP code, resolves dependencies and checks every downloaded file against the SHA-256 in the signed index. Only then does `dpkg`, Debian's own tool, unpack and configure the package. The dpkg database is still written only by dpkg, so `apt` and `dpkg` keep working normally in the Terminal.
+- **The Terminal** works as on any Debian system. Every tab already has the Wayland variables set, so starting a GTK or Qt program from it just works.
+
+[[shot:1]]
+
+## Opening them
+
+Apps with a `.desktop` file appear in the app launcher, the Classic theme's start menu and Search, with their icons. Clicking one goes through a deliberately narrow door in `lord-server`:
+
+1. The interface can only pass the **id** of a `.desktop` file that is already installed in `/usr/share/applications` or `~/.local/share/applications`, never a command.
+2. `lord-server` re-reads that file, checks it is a real, visible, non-terminal application, and builds the command from its `Exec` line by the specification, without a shell and without arguments from the caller. "Open With" in Files may add exactly one file, only if the app declares the file types it handles and the file is in your home folder or on a disk you mounted.
+3. The app is started in its own cgroup, `app-lordos-<id>.scope`, created by root, so the Monitor and the per-app firewall know which app each process belongs to.
+
+JavaScript in LordOS can't write `.desktop` files, so the interface can't invent a command: it can only pick an app that is already installed.
+
+## How they look and behave
+
+- **The frame.** Apps that ask the compositor to draw their frame (Qt apps, foot, Chromium with its system title bar) get the theme's frame. GTK 3 apps such as Firefox get it through a second decoration protocol LordOS also speaks. GTK 4 apps that draw their own bar keep it, and LordOS trims their shadow.
+- **Light and dark, live.** LordOS serves the "Settings" desktop portal itself on the session bus, so GTK 4 and libadwaita apps follow the mode, accent colour and button order. GTK 3 apps follow through the GSettings keyfile, and LordOS ships a matching GTK theme. Both change live when you switch modes.
+- **One clipboard.** Text copied in a Linux app pastes in LordOS and the other way round; images stay available after the source app closes and appear in the clipboard history (❖V).
+- **Sharp at any scale.** Each display is a separate `wl_output`, and fractional scaling lets GTK 4, Qt 6 and Chromium render sharp at 125–175 %.
+- **Touchpad gestures.** LordOS's own touchpad driver passes pinch, swipe and hold gestures to Linux apps, so pinch-to-zoom works in browsers.
+- **Games and GPU apps.** With a GPU, apps can hand LordOS GPU buffers directly (`linux-dmabuf`), use real fullscreen, lock the pointer and get raw mouse motion.
+- **Notifications** from Linux apps arrive through the standard notifications service, which `lord-server` provides, and can be configured per app in Settings.
+- **Passwords:** the standard Secret Service is served by LordOS's keyring, so browsers can keep their secrets there without another keyring daemon.
+
+[[shot:2]]
+
+[[shot:3]]
+
+## Which Wayland protocols are there
+
+`wl_compositor`, `wl_subcompositor`, `wl_shm`, `wl_output` (one per display), `xdg_wm_base` with popups, `wl_seat` (pointer, keyboard, touch), `wl_data_device_manager` (clipboard), `zxdg_decoration_manager_v1`, the KDE server-decoration protocol, `zxdg_output_manager_v1`, `wp_fractional_scale_v1`, `wp_viewporter`, `zwp_linux_dmabuf_v1`, `wp_presentation`, `zwp_relative_pointer_manager_v1`, `zwp_pointer_constraints_v1`, `zwp_pointer_gestures_v1` and `wp_cursor_shape_manager_v1`.
+
+Deliberately absent: any protocol that lets an app capture the screen or other apps' windows.
+
+[[shot:4]]
+
+## The skeptical reader's questions
+
+**Are Linux apps sandboxed?** No. This is important: they run as your user, as on any Debian system, and can read your home folder. What LordOS adds is a per-app cgroup, attribution in the Monitor, and the kernel-enforced per-app firewall (allow, deny, LAN only, no incoming connections). Only LordOS's own `.lpk` apps get the full sandbox.
+
+**Can a Linux app see other windows or record the screen?** Not through LordOS. The compositor only gives an app its own surfaces and offers no screen-capture protocol, so protected windows like Passwords stay private from them too.
+
+**What about X11-only apps?** They don't run: Xwayland is not part of LordOS. Current GTK and Qt apps speak Wayland, and so did the SDL game tested.
+
+**And Flatpak?** LordOS doesn't use or integrate it, and it hasn't been tested.
+
+**Why do packages come over HTTP?** LordOS's package engine has no TLS of its own, so `https://` sources are fetched over `http://`. The safety comes from the signatures and hashes: every index must carry a valid signature from a trusted key, can't be expired or older than the one already stored, and every file is checked against its SHA-256 before it is used. Someone on the network can see which packages you download, but can't change them.
+
+## Honest limits
+
+- **No Xwayland,** so no X11-only apps.
+- **Not yet:** drag and drop between apps, the middle-click primary selection, LordOS input methods (Korean, Japanese, Chinese) inside Linux apps, and app activation requests.
+- **SVG-only icons:** LordOS doesn't draw SVG yet. It uses the PNG icons Debian publishes for most apps, or the initial.
+- **Terminal apps** with a `.desktop` file aren't shown in the app launcher; start them from the Terminal.
+- **GTK 3 apps keep their own blue accent;** Qt 6's reading of the colour scheme from the portal hasn't been tested.
+
+## Read the source
+
+- [server/src/wl/wl.c](https://github.com/lordbasex/LordOS/blob/main/server/src/wl/wl.c): the Wayland compositor and its protocols
+- [server/src/apps.c](https://github.com/lordbasex/LordOS/blob/main/server/src/apps.c): the `.desktop` launcher
+- [server/src/ui/portal.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/portal.c): the Settings portal for GTK and libadwaita
+- [sdk/wayland.js](https://github.com/lordbasex/LordOS/blob/main/sdk/wayland.js): Linux windows in the window manager
+- [server/src/pkg](https://github.com/lordbasex/LordOS/tree/main/server/src/pkg): the Debian package engine
+- [apps/store](https://github.com/lordbasex/LordOS/tree/main/apps/store): the Store
+- [docs/WAYLAND.md](https://github.com/lordbasex/LordOS/blob/main/docs/WAYLAND.md), [docs/PACKAGES.md](https://github.com/lordbasex/LordOS/blob/main/docs/PACKAGES.md), [docs/GPU.md](https://github.com/lordbasex/LordOS/blob/main/docs/GPU.md)
diff --git a/web/content/features/linux-apps.es.md b/web/content/features/linux-apps.es.md
new file mode 100644
index 0000000..2cb9c7d
--- /dev/null
+++ b/web/content/features/linux-apps.es.md
@@ -0,0 +1,80 @@
+## En pocas palabras
+
+LordOS tiene un escritorio propio, pero abajo sigue siendo Debian. Tenés a mano las decenas de miles de programas del archivo de Debian, y las apps gráficas hechas con GTK o Qt, más navegadores como Chromium y Firefox, se abren como ventanas de LordOS, con el mismo marco, el mismo Dock y el mismo modo claro u oscuro que las apps nativas.
+
+[[shot:0]]
+
+El truco es un idioma en común. Las apps de Linux hablan **Wayland**, un protocolo para decir "acá está mi ventana, acá están mis píxeles, mandame el mouse y el teclado". El servidor gráfico de LordOS también lo habla. Así, una app que no sabe nada de LordOS igual puede vivir en su escritorio, como un viajero que habla el idioma del lugar y no necesita guía.
+
+[[diagram:linux]]
+
+## Cómo se instalan
+
+- **La Tienda** muestra las apps de Debian por categoría, con búsqueda, y te muestra un plan (qué se va a instalar o quitar) antes de hacer nada. También instala las apps `.lpk` propias de LordOS y archivos `.deb` locales.
+- **El motor de paquetes propio de LordOS** lee tus fuentes de apt, verifica los índices firmados con su propio código OpenPGP, resuelve las dependencias y controla cada archivo descargado contra el SHA-256 del índice firmado. Recién entonces `dpkg`, la herramienta propia de Debian, desempaqueta y configura el paquete. La base de datos de dpkg la sigue escribiendo solo dpkg, así que `apt` y `dpkg` siguen funcionando normalmente en la Terminal.
+- **La Terminal** funciona como en cualquier sistema Debian. Cada pestaña ya tiene las variables de Wayland configuradas, así que arrancar un programa GTK o Qt desde ahí simplemente funciona.
+
+[[shot:1]]
+
+## Cómo se abren
+
+Las apps con un archivo `.desktop` aparecen en el lanzador de apps, en el menú de inicio del tema Clásico y en Buscar, con sus íconos. Tocar una pasa por una puerta en `lord-server` que es angosta a propósito:
+
+1. La interfaz solo puede pasar el **id** de un archivo `.desktop` que ya esté instalado en `/usr/share/applications` o `~/.local/share/applications`, nunca un comando.
+2. `lord-server` vuelve a leer ese archivo, verifica que sea una aplicación real, visible y que no sea de terminal, y arma el comando a partir de su línea `Exec` según la especificación, sin shell y sin argumentos de quien llama. "Abrir con" en Archivos puede agregar exactamente un archivo, solo si la app declara los tipos de archivo que maneja y el archivo está en tu carpeta personal o en un disco que montaste.
+3. La app arranca en su propio cgroup, `app-lordos-<id>.scope`, creado por root, así el Monitor y el firewall por app saben a qué app pertenece cada proceso.
+
+El JavaScript de LordOS no puede escribir archivos `.desktop`, así que la interfaz no puede inventar un comando: solo puede elegir una app que ya está instalada.
+
+## Cómo se ven y se comportan
+
+- **El marco.** Las apps que le piden al compositor que dibuje su marco (las apps Qt, foot, Chromium con la barra de título del sistema) reciben el marco del tema. Las apps GTK 3 como Firefox lo reciben por un segundo protocolo de decoración que LordOS también habla. Las apps GTK 4 que dibujan su propia barra la conservan, y LordOS les recorta la sombra.
+- **Claro y oscuro, en vivo.** LordOS sirve por su cuenta el portal de escritorio "Settings" en el bus de la sesión, así que las apps GTK 4 y libadwaita siguen el modo, el color de acento y el orden de los botones. Las apps GTK 3 lo siguen a través del archivo de claves de GSettings, y LordOS trae un tema GTK que combina. Las dos cambian en vivo cuando cambiás de modo.
+- **Un solo portapapeles.** El texto que copiás en una app de Linux se pega en LordOS y al revés; las imágenes siguen disponibles después de cerrar la app de origen y aparecen en el historial del portapapeles (❖V).
+- **Nítidas en cualquier escala.** Cada pantalla es un `wl_output` aparte, y la escala fraccionaria permite que GTK 4, Qt 6 y Chromium se dibujen nítidos al 125–175 %.
+- **Gestos del touchpad.** El driver de touchpad propio de LordOS les pasa a las apps de Linux los gestos de pellizcar, deslizar y mantener, así que el zoom con pellizco funciona en los navegadores.
+- **Juegos y apps de GPU.** Con una GPU, las apps le pueden pasar a LordOS buffers de GPU directamente (`linux-dmabuf`), usar pantalla completa de verdad, bloquear el puntero y recibir el movimiento crudo del mouse.
+- **Las notificaciones** de las apps de Linux llegan por el servicio estándar de notificaciones, que provee `lord-server`, y se pueden configurar por app en Ajustes.
+- **Contraseñas:** el Secret Service estándar lo sirve el llavero de LordOS, así que los navegadores pueden guardar ahí sus secretos sin otro demonio de llavero.
+
+[[shot:2]]
+
+[[shot:3]]
+
+## Qué protocolos Wayland hay
+
+`wl_compositor`, `wl_subcompositor`, `wl_shm`, `wl_output` (uno por pantalla), `xdg_wm_base` con menús emergentes, `wl_seat` (puntero, teclado, táctil), `wl_data_device_manager` (portapapeles), `zxdg_decoration_manager_v1`, el protocolo de decoración del servidor de KDE, `zxdg_output_manager_v1`, `wp_fractional_scale_v1`, `wp_viewporter`, `zwp_linux_dmabuf_v1`, `wp_presentation`, `zwp_relative_pointer_manager_v1`, `zwp_pointer_constraints_v1`, `zwp_pointer_gestures_v1` y `wp_cursor_shape_manager_v1`.
+
+Ausente a propósito: cualquier protocolo que le permita a una app capturar la pantalla o las ventanas de otras apps.
+
+[[shot:4]]
+
+## Las preguntas del lector escéptico
+
+**¿Las apps de Linux están en una caja de arena?** No. Esto es importante: corren como tu usuario, como en cualquier sistema Debian, y pueden leer tu carpeta personal. Lo que LordOS suma es un cgroup por app, la atribución en el Monitor y el firewall por app que aplica el kernel (permitir, denegar, solo LAN, sin conexiones entrantes). Solo las apps `.lpk` propias de LordOS tienen la caja de arena completa.
+
+**¿Una app de Linux puede ver otras ventanas o grabar la pantalla?** No a través de LordOS. El compositor solo le da a una app sus propias superficies y no ofrece ningún protocolo de captura de pantalla, así que las ventanas protegidas como Contraseñas también quedan a salvo de ellas.
+
+**¿Y las apps que solo usan X11?** No funcionan: Xwayland no es parte de LordOS. Las apps GTK y Qt actuales hablan Wayland, y también el juego SDL que se probó.
+
+**¿Y Flatpak?** LordOS no lo usa ni lo integra, y no se probó.
+
+**¿Por qué los paquetes llegan por HTTP?** El motor de paquetes de LordOS no tiene TLS propio, así que las fuentes `https://` se descargan por `http://`. La seguridad viene de las firmas y los hashes: cada índice tiene que llevar una firma válida de una clave de confianza, no puede estar vencido ni ser más viejo que el que ya está guardado, y cada archivo se controla contra su SHA-256 antes de usarse. Alguien en la red puede ver qué paquetes descargás, pero no puede modificarlos.
+
+## Límites honestos
+
+- **Sin Xwayland,** así que no hay apps que usen solo X11.
+- **Todavía no:** arrastrar y soltar entre apps, la selección primaria con clic del medio, los métodos de entrada de LordOS (coreano, japonés, chino) dentro de las apps de Linux, y los pedidos de activación de apps.
+- **Íconos solo en SVG:** LordOS todavía no dibuja SVG. Usa los íconos PNG que publica Debian para la mayoría de las apps, o la inicial.
+- **Las apps de terminal** con archivo `.desktop` no aparecen en el lanzador de apps; arrancalas desde la Terminal.
+- **Las apps GTK 3 mantienen su propio acento azul;** la lectura del esquema de colores desde el portal en Qt 6 no se probó.
+
+## Leé el código
+
+- [server/src/wl/wl.c](https://github.com/lordbasex/LordOS/blob/main/server/src/wl/wl.c): el compositor Wayland y sus protocolos
+- [server/src/apps.c](https://github.com/lordbasex/LordOS/blob/main/server/src/apps.c): el lanzador de `.desktop`
+- [server/src/ui/portal.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/portal.c): el portal de configuración para GTK y libadwaita
+- [sdk/wayland.js](https://github.com/lordbasex/LordOS/blob/main/sdk/wayland.js): las ventanas de Linux en el gestor de ventanas
+- [server/src/pkg](https://github.com/lordbasex/LordOS/tree/main/server/src/pkg): el motor de paquetes Debian
+- [apps/store](https://github.com/lordbasex/LordOS/tree/main/apps/store): la Tienda
+- [docs/WAYLAND.md](https://github.com/lordbasex/LordOS/blob/main/docs/WAYLAND.md), [docs/PACKAGES.md](https://github.com/lordbasex/LordOS/blob/main/docs/PACKAGES.md), [docs/GPU.md](https://github.com/lordbasex/LordOS/blob/main/docs/GPU.md)
diff --git a/web/content/features/linux-apps.meta.json b/web/content/features/linux-apps.meta.json
new file mode 100644
index 0000000..f260d69
--- /dev/null
+++ b/web/content/features/linux-apps.meta.json
@@ -0,0 +1,248 @@
+{
+ "slug": "linux-apps",
+ "order": 6,
+ "title": {
+ "en": "Your Linux apps too",
+ "es": "También tus apps de Linux",
+ "pt": "Seus apps Linux também"
+ },
+ "tagline": {
+ "en": "Debian's apps, GTK, Qt and the big browsers open as LordOS windows, with the same frame and dark mode.",
+ "es": "Las apps de Debian, GTK, Qt y los grandes navegadores se abren como ventanas de LordOS, con el mismo marco y el modo oscuro.",
+ "pt": "Os apps do Debian, GTK, Qt e os grandes navegadores abrem como janelas do LordOS, com a mesma moldura e o modo escuro."
+ },
+ "lumo": {
+ "pose": "celebrate",
+ "intro": {
+ "en": "Good news: you don't have to leave your favourite apps behind! They speak Wayland, and so do I, so they move right in, wear our window frame and follow light or dark mode.",
+ "es": "Buenas noticias: ¡no tenés que dejar atrás tus apps favoritas! Hablan Wayland, igual que yo, así que se mudan directo, usan nuestro marco de ventana y siguen el modo claro u oscuro.",
+ "pt": "Boa notícia: você não precisa deixar seus apps favoritos para trás! Eles falam Wayland, e eu também, então se mudam na hora, usam nossa moldura de janela e seguem o modo claro ou escuro."
+ }
+ },
+ "screenshots": [
+ {
+ "file": "docs/app-launcher-linux-apps.png",
+ "caption": {
+ "en": "The app launcher with installed Linux apps next to the LordOS apps, each with its icon.",
+ "es": "El lanzador de apps con las apps de Linux instaladas junto a las de LordOS, cada una con su ícono.",
+ "pt": "O lançador de apps com os apps Linux instalados ao lado dos apps do LordOS, cada um com seu ícone."
+ }
+ },
+ {
+ "file": "docs/store-debian-packages.png",
+ "caption": {
+ "en": "The Store browsing Debian's apps by category.",
+ "es": "La Tienda recorriendo las apps de Debian por categoría.",
+ "pt": "A Loja navegando pelos apps do Debian por categoria."
+ }
+ },
+ {
+ "file": "docs/decorations-firefox-dark.png",
+ "caption": {
+ "en": "A Linux browser with the LordOS window frame, in dark mode.",
+ "es": "Un navegador de Linux con el marco de ventana de LordOS, en modo oscuro.",
+ "pt": "Um navegador Linux com a moldura de janela do LordOS, no modo escuro."
+ }
+ },
+ {
+ "file": "docs/decorations-gtk-dark.png",
+ "caption": {
+ "en": "A GTK 3 editor and a GTK 4 calculator following dark mode and the accent colour.",
+ "es": "Un editor GTK 3 y una calculadora GTK 4 siguiendo el modo oscuro y el color de acento.",
+ "pt": "Um editor GTK 3 e uma calculadora GTK 4 seguindo o modo escuro e a cor de destaque."
+ }
+ },
+ {
+ "file": "docs/wayland-qt6-editor.png",
+ "caption": {
+ "en": "A Qt 6 editor opened from the Terminal, with the theme's frame.",
+ "es": "Un editor Qt 6 abierto desde la Terminal, con el marco del tema.",
+ "pt": "Um editor Qt 6 aberto pelo Terminal, com a moldura do tema."
+ }
+ }
+ ],
+ "diagrams": [
+ {
+ "id": "linux",
+ "kind": "flow",
+ "title": {
+ "en": "From a click to a Linux window",
+ "es": "De un clic a una ventana de Linux",
+ "pt": "De um clique a uma janela Linux"
+ },
+ "nodes": [
+ {
+ "id": "click",
+ "label": {
+ "en": "App launcher",
+ "es": "Lanzador de apps",
+ "pt": "Lançador de apps"
+ },
+ "sub": {
+ "en": "Passes only the id of an installed .desktop",
+ "es": "Pasa solo el id de un .desktop instalado",
+ "pt": "Passa só o id de um .desktop instalado"
+ },
+ "tone": "user"
+ },
+ {
+ "id": "launch",
+ "label": {
+ "en": "Launcher in lord-server",
+ "es": "Lanzador en lord-server",
+ "pt": "Lançador no lord-server"
+ },
+ "sub": {
+ "en": "Re-reads Exec, no shell, no extra arguments",
+ "es": "Relee Exec, sin shell, sin argumentos extra",
+ "pt": "Relê o Exec, sem shell, sem argumentos extras"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "scope",
+ "label": {
+ "en": "Its own cgroup scope",
+ "es": "Su propio scope de cgroup",
+ "pt": "Seu próprio escopo de cgroup"
+ },
+ "sub": {
+ "en": "Root-owned; the firewall and Monitor use it",
+ "es": "De root; lo usan el firewall y el Monitor",
+ "pt": "Do root; usado pelo firewall e pelo Monitor"
+ },
+ "tone": "kernel"
+ },
+ {
+ "id": "app",
+ "label": {
+ "en": "GTK / Qt / browser",
+ "es": "GTK / Qt / navegador",
+ "pt": "GTK / Qt / navegador"
+ },
+ "sub": {
+ "en": "Runs as you; not sandboxed",
+ "es": "Corre como vos; sin caja de arena",
+ "pt": "Roda como você; sem sandbox"
+ },
+ "tone": "reused"
+ },
+ {
+ "id": "wl",
+ "label": {
+ "en": "LordOS Wayland compositor",
+ "es": "Compositor Wayland de LordOS",
+ "pt": "Compositor Wayland do LordOS"
+ },
+ "sub": {
+ "en": "Shows only its own surfaces, inside the theme's frame",
+ "es": "Muestra solo sus propias superficies, dentro del marco del tema",
+ "pt": "Mostra só as superfícies dele, dentro da moldura do tema"
+ },
+ "tone": "ours"
+ }
+ ],
+ "edges": [
+ {
+ "from": "click",
+ "to": "launch",
+ "label": {
+ "en": "id",
+ "es": "id",
+ "pt": "id"
+ }
+ },
+ {
+ "from": "launch",
+ "to": "scope",
+ "label": {
+ "en": "placed by root",
+ "es": "ubicado por root",
+ "pt": "posicionado pelo root"
+ }
+ },
+ {
+ "from": "scope",
+ "to": "app",
+ "label": {
+ "en": "execve",
+ "es": "execve",
+ "pt": "execve"
+ }
+ },
+ {
+ "from": "app",
+ "to": "wl",
+ "label": {
+ "en": "Wayland socket",
+ "es": "socket Wayland",
+ "pt": "socket Wayland"
+ }
+ }
+ ],
+ "caption": {
+ "en": "Linux apps connect straight to the compositor; they get the frame, the Dock and the firewall, but not the app sandbox.",
+ "es": "Las apps de Linux se conectan directo al compositor; tienen el marco, el Dock y el firewall, pero no la caja de arena de las apps.",
+ "pt": "Apps Linux se conectam direto ao compositor; ganham a moldura, o Dock e o firewall, mas não o sandbox de apps."
+ }
+ }
+ ],
+ "sources": [
+ {
+ "path": "server/src/wl/wl.c",
+ "what": {
+ "en": "The Wayland compositor",
+ "es": "El compositor Wayland",
+ "pt": "O compositor Wayland"
+ }
+ },
+ {
+ "path": "server/src/apps.c",
+ "what": {
+ "en": "The .desktop launcher",
+ "es": "El lanzador de .desktop",
+ "pt": "O lançador de .desktop"
+ }
+ },
+ {
+ "path": "server/src/ui/portal.c",
+ "what": {
+ "en": "The Settings portal for GTK",
+ "es": "El portal de configuración para GTK",
+ "pt": "O portal de configurações para GTK"
+ }
+ },
+ {
+ "path": "sdk/wayland.js",
+ "what": {
+ "en": "Linux windows in the window manager",
+ "es": "Ventanas de Linux en el gestor de ventanas",
+ "pt": "Janelas Linux no gerenciador de janelas"
+ }
+ },
+ {
+ "path": "server/src/pkg",
+ "what": {
+ "en": "The Debian package engine",
+ "es": "El motor de paquetes Debian",
+ "pt": "O motor de pacotes Debian"
+ }
+ },
+ {
+ "path": "docs/WAYLAND.md",
+ "what": {
+ "en": "Compatibility details",
+ "es": "Detalles de compatibilidad",
+ "pt": "Detalhes de compatibilidade"
+ }
+ },
+ {
+ "path": "docs/PACKAGES.md",
+ "what": {
+ "en": "How packages are verified",
+ "es": "Cómo se verifican los paquetes",
+ "pt": "Como os pacotes são verificados"
+ }
+ }
+ ]
+}
diff --git a/web/content/features/linux-apps.pt.md b/web/content/features/linux-apps.pt.md
new file mode 100644
index 0000000..473416f
--- /dev/null
+++ b/web/content/features/linux-apps.pt.md
@@ -0,0 +1,80 @@
+## Em poucas palavras
+
+O LordOS tem um desktop próprio, mas por baixo continua sendo Debian. As dezenas de milhares de programas do repositório do Debian estão disponíveis, e os apps gráficos feitos com GTK ou Qt, além de navegadores como Chromium e Firefox, abrem como janelas do LordOS, com a mesma moldura, o mesmo Dock e o mesmo modo claro ou escuro dos apps nativos.
+
+[[shot:0]]
+
+O segredo é uma língua em comum. Os apps Linux falam **Wayland**, um protocolo para dizer "esta é a minha janela, estes são os meus pixels, me mande o mouse e o teclado". O servidor gráfico do LordOS também fala essa língua. Então um app que não sabe nada do LordOS ainda consegue viver no desktop dele, como um viajante que fala o idioma local e não precisa de guia.
+
+[[diagram:linux]]
+
+## Como instalar
+
+- **A Loja** mostra os apps do Debian por categoria, com busca, e mostra um plano (o que será instalado ou removido) antes de fazer qualquer coisa. Ela também instala os apps `.lpk` do próprio LordOS e arquivos `.deb` locais.
+- **O motor de pacotes próprio do LordOS** lê suas fontes do apt, verifica os índices assinados com código OpenPGP próprio, resolve as dependências e confere cada arquivo baixado contra o SHA-256 do índice assinado. Só então o `dpkg`, a ferramenta do próprio Debian, desempacota e configura o pacote. O banco de dados do dpkg continua sendo escrito só pelo dpkg, então `apt` e `dpkg` seguem funcionando normalmente no Terminal.
+- **O Terminal** funciona como em qualquer sistema Debian. Cada aba já vem com as variáveis do Wayland definidas, então iniciar um programa GTK ou Qt por ele simplesmente funciona.
+
+[[shot:1]]
+
+## Como abrir
+
+Os apps com um arquivo `.desktop` aparecem no lançador de apps, no menu iniciar do tema Clássico e na Busca, com seus ícones. Clicar num deles passa por uma porta propositalmente estreita no `lord-server`:
+
+1. A interface só pode passar o **id** de um arquivo `.desktop` já instalado em `/usr/share/applications` ou `~/.local/share/applications`, nunca um comando.
+2. O `lord-server` relê esse arquivo, confere que é um aplicativo de verdade, visível e que não roda em terminal, e monta o comando a partir da linha `Exec` seguindo a especificação, sem shell e sem argumentos de quem chamou. O "Abrir com" do Arquivos pode acrescentar exatamente um arquivo, só se o app declarar os tipos de arquivo que trata e o arquivo estiver na sua pasta pessoal ou num disco que você montou.
+3. O app é iniciado no seu próprio cgroup, `app-lordos-<id>.scope`, criado pelo root, para que o Monitor e o firewall por app saibam a qual app pertence cada processo.
+
+O JavaScript do LordOS não consegue escrever arquivos `.desktop`, então a interface não tem como inventar um comando: ela só pode escolher um app que já está instalado.
+
+## Como eles ficam e se comportam
+
+- **A moldura.** Os apps que pedem ao compositor para desenhar sua moldura (apps Qt, foot, Chromium com a barra de título do sistema) recebem a moldura do tema. Os apps GTK 3, como o Firefox, a recebem por um segundo protocolo de decoração que o LordOS também fala. Os apps GTK 4 que desenham a própria barra a mantêm, e o LordOS apara a sombra deles.
+- **Claro e escuro, ao vivo.** O próprio LordOS serve o portal de desktop "Settings" no barramento da sessão, então os apps GTK 4 e libadwaita seguem o modo, a cor de destaque e a ordem dos botões. Os apps GTK 3 seguem pelo keyfile do GSettings, e o LordOS traz um tema GTK combinando. Os dois mudam ao vivo quando você troca de modo.
+- **Uma só área de transferência.** Um texto copiado num app Linux cola no LordOS e vice-versa; as imagens continuam disponíveis depois que o app de origem fecha e aparecem no histórico da área de transferência (❖V).
+- **Nítido em qualquer escala.** Cada tela é um `wl_output` separado, e a escala fracionária deixa GTK 4, Qt 6 e Chromium renderizarem com nitidez de 125 a 175 %.
+- **Gestos do touchpad.** O driver de touchpad próprio do LordOS repassa os gestos de pinça, deslizar e segurar aos apps Linux, então o zoom com pinça funciona nos navegadores.
+- **Jogos e apps de GPU.** Com uma GPU, os apps podem entregar buffers de GPU direto ao LordOS (`linux-dmabuf`), usar tela cheia de verdade, prender o ponteiro e receber o movimento bruto do mouse.
+- **As notificações** dos apps Linux chegam pelo serviço de notificações padrão, que o `lord-server` fornece, e podem ser configuradas por app em Ajustes.
+- **Senhas:** o Secret Service padrão é servido pelo chaveiro do LordOS, então os navegadores podem guardar seus segredos ali sem outro daemon de chaveiro.
+
+[[shot:2]]
+
+[[shot:3]]
+
+## Quais protocolos Wayland existem
+
+`wl_compositor`, `wl_subcompositor`, `wl_shm`, `wl_output` (um por tela), `xdg_wm_base` com popups, `wl_seat` (ponteiro, teclado, toque), `wl_data_device_manager` (área de transferência), `zxdg_decoration_manager_v1`, o protocolo de decoração no servidor do KDE, `zxdg_output_manager_v1`, `wp_fractional_scale_v1`, `wp_viewporter`, `zwp_linux_dmabuf_v1`, `wp_presentation`, `zwp_relative_pointer_manager_v1`, `zwp_pointer_constraints_v1`, `zwp_pointer_gestures_v1` e `wp_cursor_shape_manager_v1`.
+
+Ausente de propósito: qualquer protocolo que permita a um app capturar a tela ou as janelas de outros apps.
+
+[[shot:4]]
+
+## As perguntas do leitor cético
+
+**Os apps Linux ficam em sandbox?** Não. Isso é importante: eles rodam como o seu usuário, como em qualquer sistema Debian, e podem ler sua pasta pessoal. O que o LordOS acrescenta é um cgroup por app, a atribuição no Monitor e o firewall por app aplicado pelo kernel (permitir, negar, só LAN, sem conexões de entrada). Só os apps `.lpk` do próprio LordOS recebem o sandbox completo.
+
+**Um app Linux consegue ver outras janelas ou gravar a tela?** Não pelo LordOS. O compositor só entrega a um app as superfícies dele mesmo e não oferece nenhum protocolo de captura de tela, então janelas protegidas como a de Senhas também ficam privadas para eles.
+
+**E os apps que só falam X11?** Não rodam: o Xwayland não faz parte do LordOS. Os apps GTK e Qt atuais falam Wayland, e o jogo SDL testado também.
+
+**E o Flatpak?** O LordOS não o usa nem o integra, e ele não foi testado.
+
+**Por que os pacotes vêm por HTTP?** O motor de pacotes do LordOS não tem TLS próprio, então as fontes `https://` são baixadas por `http://`. A segurança vem das assinaturas e dos hashes: todo índice precisa ter uma assinatura válida de uma chave confiável, não pode estar expirado nem ser mais antigo que o já guardado, e cada arquivo é conferido contra seu SHA-256 antes de ser usado. Alguém na rede consegue ver quais pacotes você baixa, mas não consegue alterá-los.
+
+## Limites honestos
+
+- **Sem Xwayland,** então nada de apps só X11.
+- **Ainda não:** arrastar e soltar entre apps, a seleção primária do clique do meio, os métodos de entrada do LordOS (coreano, japonês, chinês) dentro dos apps Linux e os pedidos de ativação de apps.
+- **Ícones só em SVG:** o LordOS ainda não desenha SVG. Ele usa os ícones PNG que o Debian publica para a maioria dos apps, ou a inicial.
+- **Apps de terminal** com arquivo `.desktop` não aparecem no lançador de apps; inicie-os pelo Terminal.
+- **Os apps GTK 3 mantêm o próprio destaque azul;** a leitura do esquema de cores pelo portal no Qt 6 não foi testada.
+
+## Leia o código
+
+- [server/src/wl/wl.c](https://github.com/lordbasex/LordOS/blob/main/server/src/wl/wl.c): o compositor Wayland e seus protocolos
+- [server/src/apps.c](https://github.com/lordbasex/LordOS/blob/main/server/src/apps.c): o lançador de `.desktop`
+- [server/src/ui/portal.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/portal.c): o portal de configurações para GTK e libadwaita
+- [sdk/wayland.js](https://github.com/lordbasex/LordOS/blob/main/sdk/wayland.js): as janelas Linux no gerenciador de janelas
+- [server/src/pkg](https://github.com/lordbasex/LordOS/tree/main/server/src/pkg): o motor de pacotes Debian
+- [apps/store](https://github.com/lordbasex/LordOS/tree/main/apps/store): a Loja
+- [docs/WAYLAND.md](https://github.com/lordbasex/LordOS/blob/main/docs/WAYLAND.md), [docs/PACKAGES.md](https://github.com/lordbasex/LordOS/blob/main/docs/PACKAGES.md), [docs/GPU.md](https://github.com/lordbasex/LordOS/blob/main/docs/GPU.md)
diff --git a/web/content/features/mail-calendar.en.md b/web/content/features/mail-calendar.en.md
new file mode 100644
index 0000000..0cce30c
--- /dev/null
+++ b/web/content/features/mail-calendar.en.md
@@ -0,0 +1,70 @@
+## The short version
+
+LordOS ships four native apps for your personal information: **Mail**, **Calendar**, **Contacts** and **Reminders**. They are ordinary LordOS apps, drawn by the same engine as the rest of the desktop. What is unusual is where the risky work happens: every network protocol and every parser of data that comes from outside runs in one locked-in helper process, **`lord-maild`**, which is not even allowed to open a network connection by itself.
+
+[[shot:0]]
+
+Mail is the most common way to attack a computer. A message is a stranger's document: HTML, images, attachments, invitations. So LordOS treats it like a parcel that is opened in a sealed room. If something in it is malicious and takes over the room, it still can't call out, can't run anything, and can't reach your files.
+
+[[diagram:mail]]
+
+## What you get
+
+- **Mail:** three panes, a unified inbox, conversations, flags and six colour categories that other clients see too, signatures, drafts saved to the server, "send later", attachments opened with your default apps, and notifications for new mail. Compose in rich text, markdown or plain text.
+- **Calendar:** day, week and month views, several calendars with colours, local or synced over CalDAV, repeating events, and alarms.
+- **Invitations** that arrive by mail: Accept, Maybe or Decline. The event goes into Calendar and the reply goes to the organizer.
+- **Reminders:** lists, due dates, priorities, flags, and Today / Scheduled / All / Flagged / Completed views, synced over CalDAV.
+- **Contacts:** local or synced over CardDAV, groups and photos. Mail autocompletes from them.
+- **Alarms ring with the apps closed,** because the helper keeps running for the session.
+- **Any IMAP and SMTP account** works. For a few widely used providers the server settings are filled in from a built-in table, with nothing looked up online.
+
+[[shot:5]]
+
+[[shot:6]]
+
+## How it works
+
+1. **The helper starts locked in.** `lord-server` launches `lord-maild` from a fixed path, with no arguments and a minimal environment. Before reading anything from the network it loads the system's certificate authorities and locks itself in with the same helper sandbox as LordOS's other decoders: write access only to its cache folder, no `socket`, `connect`, `bind`, `execve` or `fork`, threads only, no capabilities, its own cgroup.
+2. **It asks for each connection.** To reach a server it sends `lord-server` a request: host and port. `lord-server` checks that endpoint against your accounts file, and only then connects and passes the connected socket back. Allowed endpoints are exactly your accounts' IMAP, SMTP and calendar/contacts servers, plus other hosts of the same domain on port 443 when a calendar server redirects during discovery.
+3. **TLS is checked properly.** Every connection is verified against the system's certificate store and the server name. A certificate that doesn't verify is never accepted silently: Mail shows the problem and its fingerprint, and only if you press *Trust This Certificate* is that exact certificate remembered for that account.
+4. **HTML is translated, not executed.** LordOS has no web engine, and Mail doesn't need one. LordOS's own sanitizer turns a message's HTML into a small tree of blocks, tables, text runs, images and links, and Mail draws it with native views. Scripts, styles, frames, forms, SVG, media, event handlers and hidden "preheader" tricks are dropped.
+
+## What you see and decide
+
+- **Remote images are blocked** until you press *Load Images* for that message or *Always from this sender*. Even then, `lord-server` allows only those image hosts, on ports 80 and 443, for ten minutes, and refuses any address that isn't public (local network, loopback, cloud metadata and similar), checked on the address it actually connects to. Tracking pixels are counted and never shown.
+- **Deceptive links are flagged** in red with a warning when the visible text looks like an address but points somewhere else, or uses tricks like an IP address, `user@` or look-alike characters. Clicking shows the real destination. Mail never opens a browser by itself; you can copy the address.
+- **Passwords never touch a file.** Mail stores account passwords in the system keyring (see Passwords) and hands them to `lord-maild` in memory only. The accounts file holds servers, user names, signatures and trusted certificate fingerprints, and the code refuses to write a password into it.
+
+[[shot:1]]
+
+[[shot:2]]
+
+## The skeptical reader's questions
+
+**What if a message exploits a bug in the parser?** That is what the design assumes will eventually happen. The parser runs in `lord-maild`, which can't create sockets, can't run programs and can only write to its own cache. The parsers are tested heavily: 30,953 checks in `mail-test`, including mutation fuzzing of MIME, charsets, the HTML sanitizer, iCalendar, vCard and XML, plus separate suites for the network layer and the connector.
+
+**Could a hijacked helper talk to my local network?** Only to the servers in your accounts file. Image grants are limited to public addresses, and the check runs on the address actually connected, so a DNS trick can't redirect it to your router.
+
+**Does the desktop freeze while mail syncs?** No. Requests are asynchronous; inside the helper, network work runs on one thread per account. Measured on a test VM: a 10,000-message folder syncs in about 2 s and opens from the local cache in about 20 ms.
+
+**Is OAuth sign-in supported?** It is prepared but disabled. Large providers only issue sign-in tokens to applications registered with them, so it needs a registered client ID. Until then, those accounts use app passwords.
+
+[[shot:3]]
+
+[[shot:4]]
+
+## Honest limits
+
+- **No real provider accounts have been tested.** The test VM used local IMAP, SMTP and CalDAV/CardDAV servers with a test certificate authority. The built-in provider settings come from the providers' published values.
+- **Not yet:** editing a single occurrence of a repeating event, creating calendars or address books on the server, multibyte CJK charsets, encrypted or signed mail (S/MIME and OpenPGP), and IMAP QRESYNC.
+- **OAuth sign-in** is disabled until a client ID is registered.
+
+## Read the source
+
+- [server/src/mail/maild.c](https://github.com/lordbasex/LordOS/blob/main/server/src/mail/maild.c): the `lord-maild` helper and its sandbox
+- [server/src/mail/mailc.c](https://github.com/lordbasex/LordOS/blob/main/server/src/mail/mailc.c): the connector in `lord-server` that decides which endpoints are allowed
+- [server/src/mail/html.c](https://github.com/lordbasex/LordOS/blob/main/server/src/mail/html.c): the HTML sanitizer
+- [server/src/ui/js_mail.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/js_mail.c): `lord.mail`, the session API
+- [apps/mail](https://github.com/lordbasex/LordOS/tree/main/apps/mail), [apps/calendar](https://github.com/lordbasex/LordOS/tree/main/apps/calendar), [apps/contacts](https://github.com/lordbasex/LordOS/tree/main/apps/contacts), [apps/reminders](https://github.com/lordbasex/LordOS/tree/main/apps/reminders)
+- [server/tests/mail_test.c](https://github.com/lordbasex/LordOS/blob/main/server/tests/mail_test.c): the parser and sanitizer tests
+- [docs/MAIL.md](https://github.com/lordbasex/LordOS/blob/main/docs/MAIL.md)
diff --git a/web/content/features/mail-calendar.es.md b/web/content/features/mail-calendar.es.md
new file mode 100644
index 0000000..ad66fc6
--- /dev/null
+++ b/web/content/features/mail-calendar.es.md
@@ -0,0 +1,70 @@
+## En pocas palabras
+
+LordOS trae cuatro apps nativas para tu información personal: **Mail**, **Calendario**, **Contactos** y **Recordatorios**. Son apps comunes de LordOS, dibujadas por el mismo motor que el resto del escritorio. Lo inusual es dónde se hace el trabajo riesgoso: cada protocolo de red y cada lector de datos que vienen de afuera corre en un único proceso ayudante encerrado, **`lord-maild`**, que ni siquiera tiene permitido abrir una conexión de red por su cuenta.
+
+[[shot:0]]
+
+El correo es la forma más común de atacar una computadora. Un mensaje es un documento de un desconocido: HTML, imágenes, adjuntos, invitaciones. Por eso LordOS lo trata como un paquete que se abre en una habitación sellada. Si algo adentro es malicioso y toma la habitación, igual no puede llamar afuera, no puede ejecutar nada y no puede llegar a tus archivos.
+
+[[diagram:mail]]
+
+## Qué tenés
+
+- **Mail:** tres paneles, bandeja de entrada unificada, conversaciones, marcas y seis categorías de color que también ven otros clientes, firmas, borradores guardados en el servidor, "enviar más tarde", adjuntos que se abren con tus apps predeterminadas y notificaciones de correo nuevo. Escribís en texto enriquecido, markdown o texto plano.
+- **Calendario:** vistas de día, semana y mes, varios calendarios con colores, locales o sincronizados por CalDAV, eventos que se repiten y alarmas.
+- **Invitaciones** que llegan por correo: Aceptar, Quizás o Rechazar. El evento va al Calendario y la respuesta le llega al organizador.
+- **Recordatorios:** listas, fechas de vencimiento, prioridades, banderas y las vistas Hoy / Programados / Todos / Con bandera / Completados, sincronizados por CalDAV.
+- **Contactos:** locales o sincronizados por CardDAV, con grupos y fotos. Mail autocompleta a partir de ellos.
+- **Las alarmas suenan con las apps cerradas,** porque el ayudante sigue corriendo durante toda la sesión.
+- **Cualquier cuenta IMAP y SMTP** funciona. Para algunos proveedores muy usados, la configuración de servidores se completa desde una tabla incluida, sin consultar nada en línea.
+
+[[shot:5]]
+
+[[shot:6]]
+
+## Cómo funciona
+
+1. **El ayudante arranca encerrado.** `lord-server` lanza `lord-maild` desde una ruta fija, sin argumentos y con un entorno mínimo. Antes de leer nada de la red, carga las autoridades certificantes del sistema y se encierra con la misma caja de arena para ayudantes que los otros decodificadores de LordOS: escritura solo en su carpeta de caché, sin `socket`, `connect`, `bind`, `execve` ni `fork`, solo hilos, sin capacidades, con su propio cgroup.
+2. **Pide cada conexión.** Para llegar a un servidor le manda a `lord-server` un pedido: host y puerto. `lord-server` compara ese destino con tu archivo de cuentas, y recién entonces se conecta y le devuelve el socket conectado. Los destinos permitidos son exactamente los servidores IMAP, SMTP y de calendario/contactos de tus cuentas, más otros hosts del mismo dominio en el puerto 443 cuando un servidor de calendario redirige durante el descubrimiento.
+3. **TLS se verifica como corresponde.** Cada conexión se verifica contra el almacén de certificados del sistema y el nombre del servidor. Un certificado que no verifica nunca se acepta en silencio: Mail muestra el problema y su huella, y solo si tocás *Confiar en este certificado* se recuerda exactamente ese certificado para esa cuenta.
+4. **El HTML se traduce, no se ejecuta.** LordOS no tiene motor web, y Mail no lo necesita. El sanitizador propio de LordOS convierte el HTML de un mensaje en un árbol chico de bloques, tablas, tramos de texto, imágenes y enlaces, y Mail lo dibuja con vistas nativas. Se descartan scripts, estilos, frames, formularios, SVG, multimedia, manejadores de eventos y los trucos de "preencabezado" oculto.
+
+## Qué ves y qué decidís
+
+- **Las imágenes remotas están bloqueadas** hasta que tocás *Cargar imágenes* para ese mensaje o *Siempre de este remitente*. Incluso así, `lord-server` permite solo esos hosts de imágenes, en los puertos 80 y 443, por diez minutos, y rechaza cualquier dirección que no sea pública (red local, loopback, metadatos de la nube y similares), verificada sobre la dirección a la que de verdad se conecta. Los píxeles de rastreo se cuentan y nunca se muestran.
+- **Los enlaces engañosos se marcan** en rojo con una advertencia cuando el texto visible parece una dirección pero apunta a otro lado, o usa trucos como una dirección IP, `user@` o caracteres parecidos. Al tocarlo se muestra el destino real. Mail nunca abre un navegador por su cuenta; podés copiar la dirección.
+- **Las contraseñas nunca tocan un archivo.** Mail guarda las contraseñas de las cuentas en el llavero del sistema (ver Contraseñas) y se las pasa a `lord-maild` solo en memoria. El archivo de cuentas guarda servidores, nombres de usuario, firmas y huellas de certificados de confianza, y el código se niega a escribir una contraseña ahí.
+
+[[shot:1]]
+
+[[shot:2]]
+
+## Las preguntas del lector escéptico
+
+**¿Y si un mensaje aprovecha un error en el lector?** Es justamente lo que el diseño supone que en algún momento va a pasar. El lector corre en `lord-maild`, que no puede crear sockets, no puede ejecutar programas y solo puede escribir en su propia caché. Los lectores se prueban a fondo: 30.953 controles en `mail-test`, con fuzzing por mutación de MIME, juegos de caracteres, el sanitizador de HTML, iCalendar, vCard y XML, más baterías aparte para la capa de red y el conector.
+
+**¿Un ayudante tomado podría hablar con mi red local?** Solo con los servidores de tu archivo de cuentas. Los permisos para imágenes se limitan a direcciones públicas, y el control corre sobre la dirección a la que realmente se conectó, así que un truco de DNS no lo puede redirigir a tu router.
+
+**¿Se congela el escritorio mientras se sincroniza el correo?** No. Los pedidos son asíncronos; dentro del ayudante, el trabajo de red corre en un hilo por cuenta. Medido en una VM de prueba: una carpeta de 10.000 mensajes se sincroniza en unos 2 s y se abre desde la caché local en unos 20 ms.
+
+**¿Se puede ingresar con OAuth?** Está preparado pero desactivado. Los proveedores grandes solo dan tokens de ingreso a aplicaciones registradas con ellos, así que hace falta un ID de cliente registrado. Hasta entonces, esas cuentas usan contraseñas de aplicación.
+
+[[shot:3]]
+
+[[shot:4]]
+
+## Límites honestos
+
+- **No se probaron cuentas de proveedores reales.** La VM de prueba usó servidores IMAP, SMTP y CalDAV/CardDAV locales con una autoridad certificante de prueba. La configuración incluida de los proveedores sale de los valores que publican ellos.
+- **Todavía no:** editar una sola repetición de un evento que se repite, crear calendarios o libretas de direcciones en el servidor, juegos de caracteres CJK multibyte, correo cifrado o firmado (S/MIME y OpenPGP) e IMAP QRESYNC.
+- **El ingreso con OAuth** está desactivado hasta que se registre un ID de cliente.
+
+## Leé el código
+
+- [server/src/mail/maild.c](https://github.com/lordbasex/LordOS/blob/main/server/src/mail/maild.c): el ayudante `lord-maild` y su caja de arena
+- [server/src/mail/mailc.c](https://github.com/lordbasex/LordOS/blob/main/server/src/mail/mailc.c): el conector en `lord-server` que decide qué destinos se permiten
+- [server/src/mail/html.c](https://github.com/lordbasex/LordOS/blob/main/server/src/mail/html.c): el sanitizador de HTML
+- [server/src/ui/js_mail.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/js_mail.c): `lord.mail`, la API de la sesión
+- [apps/mail](https://github.com/lordbasex/LordOS/tree/main/apps/mail), [apps/calendar](https://github.com/lordbasex/LordOS/tree/main/apps/calendar), [apps/contacts](https://github.com/lordbasex/LordOS/tree/main/apps/contacts), [apps/reminders](https://github.com/lordbasex/LordOS/tree/main/apps/reminders)
+- [server/tests/mail_test.c](https://github.com/lordbasex/LordOS/blob/main/server/tests/mail_test.c): las pruebas de los lectores y el sanitizador
+- [docs/MAIL.md](https://github.com/lordbasex/LordOS/blob/main/docs/MAIL.md)
diff --git a/web/content/features/mail-calendar.meta.json b/web/content/features/mail-calendar.meta.json
new file mode 100644
index 0000000..56ab54e
--- /dev/null
+++ b/web/content/features/mail-calendar.meta.json
@@ -0,0 +1,241 @@
+{
+ "slug": "mail-calendar",
+ "order": 5,
+ "title": {
+ "en": "Mail, Calendar, Contacts and Reminders",
+ "es": "Correo, Calendario, Contactos y Recordatorios",
+ "pt": "E-mail, Calendário, Contatos e Lembretes"
+ },
+ "tagline": {
+ "en": "Native apps for your accounts, with every risky parser locked in a helper that can't open a connection on its own.",
+ "es": "Apps nativas para tus cuentas, con cada lector riesgoso encerrado en un ayudante que no puede abrir una conexión por su cuenta.",
+ "pt": "Apps nativos para suas contas, com cada leitor arriscado trancado num ajudante que não consegue abrir uma conexão sozinho."
+ },
+ "lumo": {
+ "pose": "run",
+ "intro": {
+ "en": "Mail keeps me running! Every message is a parcel from a stranger, so I open it in a sealed room, keep the pictures hidden until you say so, and point out links that aren't what they seem.",
+ "es": "¡El correo me tiene corriendo! Cada mensaje es un paquete de un desconocido, así que lo abro en una habitación sellada, escondo las imágenes hasta que me digas y te marco los enlaces que no son lo que parecen.",
+ "pt": "O e-mail me faz correr! Cada mensagem é um pacote de um desconhecido, então eu abro numa sala lacrada, escondo as imagens até você mandar e aponto os links que não são o que parecem."
+ }
+ },
+ "screenshots": [
+ {
+ "file": "docs/mail-threads.png",
+ "caption": {
+ "en": "Mail: three panes and a whole conversation, including your own replies.",
+ "es": "Correo: tres paneles y una conversación completa, incluidas tus respuestas.",
+ "pt": "E-mail: três painéis e uma conversa inteira, incluindo suas respostas."
+ }
+ },
+ {
+ "file": "docs/mail-html-images-blocked.png",
+ "caption": {
+ "en": "A newsletter with its remote images blocked until you ask for them.",
+ "es": "Un boletín con sus imágenes remotas bloqueadas hasta que las pidas.",
+ "pt": "Um boletim com as imagens remotas bloqueadas até você pedir."
+ }
+ },
+ {
+ "file": "docs/mail-deceptive-link.png",
+ "caption": {
+ "en": "A deceptive link flagged in red, with its real destination.",
+ "es": "Un enlace engañoso marcado en rojo, con su destino real.",
+ "pt": "Um link enganoso marcado em vermelho, com o destino real."
+ }
+ },
+ {
+ "file": "docs/calendar-week.png",
+ "caption": {
+ "en": "Calendar, week view, with several coloured calendars.",
+ "es": "Calendario, vista semanal, con varios calendarios de colores.",
+ "pt": "Calendário, visão semanal, com vários calendários coloridos."
+ }
+ },
+ {
+ "file": "docs/mail-invitation.png",
+ "caption": {
+ "en": "An invitation in Mail: Accept, Maybe or Decline, and the reply goes to the organizer.",
+ "es": "Una invitación en Correo: Aceptar, Quizás o Rechazar, y la respuesta va al organizador.",
+ "pt": "Um convite no E-mail: Aceitar, Talvez ou Recusar, e a resposta vai ao organizador."
+ }
+ },
+ {
+ "file": "docs/reminders.png",
+ "caption": {
+ "en": "Reminders with lists, due dates, priorities and flags.",
+ "es": "Recordatorios con listas, fechas, prioridades y marcas.",
+ "pt": "Lembretes com listas, prazos, prioridades e sinalizadores."
+ }
+ },
+ {
+ "file": "docs/contacts.png",
+ "caption": {
+ "en": "Contacts, local or synced, with groups and photos.",
+ "es": "Contactos, locales o sincronizados, con grupos y fotos.",
+ "pt": "Contatos, locais ou sincronizados, com grupos e fotos."
+ }
+ }
+ ],
+ "diagrams": [
+ {
+ "id": "mail",
+ "kind": "flow",
+ "title": {
+ "en": "Who talks to the mail server",
+ "es": "Quién habla con el servidor de correo",
+ "pt": "Quem fala com o servidor de e-mail"
+ },
+ "nodes": [
+ {
+ "id": "apps",
+ "label": {
+ "en": "Mail, Calendar, Contacts, Reminders",
+ "es": "Correo, Calendario, Contactos, Recordatorios",
+ "pt": "E-mail, Calendário, Contatos, Lembretes"
+ },
+ "sub": {
+ "en": "Native apps; asynchronous requests",
+ "es": "Apps nativas; pedidos asíncronos",
+ "pt": "Apps nativos; pedidos assíncronos"
+ },
+ "tone": "user"
+ },
+ {
+ "id": "maild",
+ "label": {
+ "en": "lord-maild",
+ "es": "lord-maild",
+ "pt": "lord-maild"
+ },
+ "sub": {
+ "en": "Sandboxed: TLS, IMAP, SMTP, DAV, MIME, HTML; no sockets of its own",
+ "es": "En caja de arena: TLS, IMAP, SMTP, DAV, MIME, HTML; sin sockets propios",
+ "pt": "Em sandbox: TLS, IMAP, SMTP, DAV, MIME, HTML; sem sockets próprios"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "connector",
+ "label": {
+ "en": "Connector in lord-server",
+ "es": "Conector en lord-server",
+ "pt": "Conector no lord-server"
+ },
+ "sub": {
+ "en": "Connects only to servers in your accounts file",
+ "es": "Conecta solo con los servidores de tu archivo de cuentas",
+ "pt": "Conecta só aos servidores do seu arquivo de contas"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "servers",
+ "label": {
+ "en": "Your mail and calendar servers",
+ "es": "Tus servidores de correo y calendario",
+ "pt": "Seus servidores de e-mail e calendário"
+ },
+ "sub": {
+ "en": "Certificates verified; failures shown",
+ "es": "Certificados verificados; los errores se muestran",
+ "pt": "Certificados verificados; falhas exibidas"
+ },
+ "tone": "reused"
+ }
+ ],
+ "edges": [
+ {
+ "from": "apps",
+ "to": "maild",
+ "label": {
+ "en": "JSON over a channel",
+ "es": "JSON por un canal",
+ "pt": "JSON por um canal"
+ }
+ },
+ {
+ "from": "maild",
+ "to": "connector",
+ "label": {
+ "en": "\"connect host:port?\"",
+ "es": "\"¿conectar host:puerto?\"",
+ "pt": "\"conectar host:porta?\""
+ }
+ },
+ {
+ "from": "connector",
+ "to": "servers",
+ "label": {
+ "en": "allowed endpoint only",
+ "es": "solo destinos permitidos",
+ "pt": "só destinos permitidos"
+ }
+ }
+ ],
+ "caption": {
+ "en": "The helper that parses untrusted mail can't open a connection; lord-server opens it only to approved servers and hands it over.",
+ "es": "El ayudante que lee correo no confiable no puede abrir una conexión; lord-server la abre solo hacia servidores aprobados y se la pasa.",
+ "pt": "O ajudante que lê e-mail não confiável não consegue abrir conexão; o lord-server abre só para servidores aprovados e a entrega."
+ }
+ }
+ ],
+ "sources": [
+ {
+ "path": "server/src/mail/maild.c",
+ "what": {
+ "en": "The lord-maild helper",
+ "es": "El ayudante lord-maild",
+ "pt": "O ajudante lord-maild"
+ }
+ },
+ {
+ "path": "server/src/mail/mailc.c",
+ "what": {
+ "en": "The connector and endpoint checks",
+ "es": "El conector y el control de destinos",
+ "pt": "O conector e a checagem de destinos"
+ }
+ },
+ {
+ "path": "server/src/mail/html.c",
+ "what": {
+ "en": "The HTML sanitizer",
+ "es": "El sanitizador de HTML",
+ "pt": "O sanitizador de HTML"
+ }
+ },
+ {
+ "path": "server/src/ui/js_mail.c",
+ "what": {
+ "en": "lord.mail, the session API",
+ "es": "lord.mail, la API de la sesión",
+ "pt": "lord.mail, a API da sessão"
+ }
+ },
+ {
+ "path": "apps/mail",
+ "what": {
+ "en": "The Mail app",
+ "es": "La app Correo",
+ "pt": "O app E-mail"
+ }
+ },
+ {
+ "path": "server/tests/mail_test.c",
+ "what": {
+ "en": "Parser and sanitizer tests",
+ "es": "Pruebas de lectores y sanitizador",
+ "pt": "Testes dos leitores e do sanitizador"
+ }
+ },
+ {
+ "path": "docs/MAIL.md",
+ "what": {
+ "en": "Full design and tests",
+ "es": "Diseño completo y pruebas",
+ "pt": "Projeto completo e testes"
+ }
+ }
+ ]
+}
diff --git a/web/content/features/mail-calendar.pt.md b/web/content/features/mail-calendar.pt.md
new file mode 100644
index 0000000..c8ea5bd
--- /dev/null
+++ b/web/content/features/mail-calendar.pt.md
@@ -0,0 +1,70 @@
+## Em poucas palavras
+
+O LordOS traz quatro apps nativos para suas informações pessoais: **E-mail**, **Calendário**, **Contatos** e **Lembretes**. São apps comuns do LordOS, desenhados pelo mesmo motor que o resto do desktop. O incomum é onde acontece o trabalho arriscado: todo protocolo de rede e todo leitor de dados vindos de fora roda num único processo ajudante trancado, o **`lord-maild`**, que nem tem permissão para abrir uma conexão de rede sozinho.
+
+[[shot:0]]
+
+O e-mail é o caminho mais comum para atacar um computador. Uma mensagem é um documento de um desconhecido: HTML, imagens, anexos, convites. Por isso o LordOS a trata como um pacote aberto numa sala lacrada. Se algo nele for malicioso e tomar conta da sala, ainda assim não consegue chamar ninguém lá fora, não consegue executar nada e não alcança seus arquivos.
+
+[[diagram:mail]]
+
+## O que você ganha
+
+- **E-mail:** três painéis, caixa de entrada unificada, conversas, sinalizadores e seis categorias coloridas que outros clientes também enxergam, assinaturas, rascunhos salvos no servidor, "enviar mais tarde", anexos abertos com seus apps padrão e notificações de e-mails novos. Escreva em texto formatado, markdown ou texto simples.
+- **Calendário:** visões de dia, semana e mês, vários calendários coloridos, locais ou sincronizados por CalDAV, eventos que se repetem e alarmes.
+- **Convites** que chegam por e-mail: Aceitar, Talvez ou Recusar. O evento entra no Calendário e a resposta vai para o organizador.
+- **Lembretes:** listas, prazos, prioridades, sinalizadores e as visões Hoje / Agendados / Todos / Sinalizados / Concluídos, sincronizados por CalDAV.
+- **Contatos:** locais ou sincronizados por CardDAV, com grupos e fotos. O E-mail completa os endereços a partir deles.
+- **Os alarmes tocam com os apps fechados,** porque o ajudante continua rodando durante a sessão.
+- **Qualquer conta IMAP e SMTP** funciona. Para alguns provedores muito usados, as configurações do servidor são preenchidas a partir de uma tabela embutida, sem consultar nada online.
+
+[[shot:5]]
+
+[[shot:6]]
+
+## Como funciona
+
+1. **O ajudante já começa trancado.** O `lord-server` inicia o `lord-maild` a partir de um caminho fixo, sem argumentos e com um ambiente mínimo. Antes de ler qualquer coisa da rede, ele carrega as autoridades certificadoras do sistema e se tranca com o mesmo sandbox de ajudante dos outros decodificadores do LordOS: escrita só na sua pasta de cache, sem `socket`, `connect`, `bind`, `execve` nem `fork`, só threads, sem capacidades, com cgroup próprio.
+2. **Ele pede cada conexão.** Para alcançar um servidor, ele manda ao `lord-server` um pedido: host e porta. O `lord-server` confere esse destino no seu arquivo de contas e só então conecta e devolve o socket já conectado. Os destinos permitidos são exatamente os servidores IMAP, SMTP e de calendário/contatos das suas contas, mais outros hosts do mesmo domínio na porta 443 quando um servidor de calendário redireciona durante a descoberta.
+3. **O TLS é conferido direito.** Toda conexão é verificada contra o repositório de certificados do sistema e o nome do servidor. Um certificado que não passa na verificação nunca é aceito em silêncio: o E-mail mostra o problema e a impressão digital, e só se você apertar *Confiar neste certificado* aquele certificado exato fica lembrado para aquela conta.
+4. **O HTML é traduzido, não executado.** O LordOS não tem motor web, e o E-mail não precisa de um. O sanitizador próprio do LordOS transforma o HTML de uma mensagem numa pequena árvore de blocos, tabelas, trechos de texto, imagens e links, e o E-mail a desenha com views nativas. Scripts, estilos, frames, formulários, SVG, mídia, tratadores de eventos e truques de "preheader" escondido são descartados.
+
+## O que você vê e decide
+
+- **As imagens remotas ficam bloqueadas** até você apertar *Carregar imagens* para aquela mensagem ou *Sempre deste remetente*. Mesmo assim, o `lord-server` libera só aqueles hosts de imagem, nas portas 80 e 443, por dez minutos, e recusa qualquer endereço que não seja público (rede local, loopback, metadados de nuvem e similares), conferido no endereço com que ele de fato se conecta. Pixels de rastreamento são contados e nunca exibidos.
+- **Links enganosos são marcados** em vermelho com um aviso quando o texto visível parece um endereço mas aponta para outro lugar, ou usa truques como um endereço IP, `user@` ou caracteres parecidos. Clicar mostra o destino real. O E-mail nunca abre um navegador sozinho; você pode copiar o endereço.
+- **As senhas nunca tocam um arquivo.** O E-mail guarda as senhas das contas no chaveiro do sistema (veja Senhas) e as entrega ao `lord-maild` só em memória. O arquivo de contas guarda servidores, nomes de usuário, assinaturas e impressões digitais de certificados confiáveis, e o código se recusa a gravar uma senha nele.
+
+[[shot:1]]
+
+[[shot:2]]
+
+## As perguntas do leitor cético
+
+**E se uma mensagem explorar um bug no leitor?** É exatamente o que o projeto supõe que um dia vai acontecer. O leitor roda no `lord-maild`, que não consegue criar sockets, não consegue executar programas e só pode escrever no próprio cache. Os leitores são testados a fundo: 30.953 verificações no `mail-test`, incluindo fuzzing por mutação de MIME, conjuntos de caracteres, o sanitizador de HTML, iCalendar, vCard e XML, além de suítes separadas para a camada de rede e para o conector.
+
+**Um ajudante sequestrado poderia falar com a minha rede local?** Só com os servidores do seu arquivo de contas. As liberações de imagens se limitam a endereços públicos, e a verificação é feita no endereço realmente conectado, então um truque de DNS não consegue redirecioná-lo para o seu roteador.
+
+**O desktop trava enquanto o e-mail sincroniza?** Não. Os pedidos são assíncronos; dentro do ajudante, o trabalho de rede roda numa thread por conta. Medido numa VM de teste: uma pasta com 10.000 mensagens sincroniza em cerca de 2 s e abre a partir do cache local em cerca de 20 ms.
+
+**O login por OAuth é suportado?** Está preparado, mas desativado. Os grandes provedores só emitem tokens de login para aplicativos registrados com eles, então é preciso um client ID registrado. Até lá, essas contas usam senhas de app.
+
+[[shot:3]]
+
+[[shot:4]]
+
+## Limites honestos
+
+- **Nenhuma conta de provedor real foi testada.** A VM de teste usou servidores IMAP, SMTP e CalDAV/CardDAV locais, com uma autoridade certificadora de teste. As configurações de provedores embutidas vêm dos valores publicados pelos próprios provedores.
+- **Ainda não:** editar uma única ocorrência de um evento que se repete, criar calendários ou catálogos de endereços no servidor, conjuntos de caracteres CJK multibyte, e-mail criptografado ou assinado (S/MIME e OpenPGP) e IMAP QRESYNC.
+- **O login por OAuth** fica desativado até um client ID ser registrado.
+
+## Leia o código
+
+- [server/src/mail/maild.c](https://github.com/lordbasex/LordOS/blob/main/server/src/mail/maild.c): o ajudante `lord-maild` e seu sandbox
+- [server/src/mail/mailc.c](https://github.com/lordbasex/LordOS/blob/main/server/src/mail/mailc.c): o conector no `lord-server` que decide quais destinos são permitidos
+- [server/src/mail/html.c](https://github.com/lordbasex/LordOS/blob/main/server/src/mail/html.c): o sanitizador de HTML
+- [server/src/ui/js_mail.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/js_mail.c): `lord.mail`, a API da sessão
+- [apps/mail](https://github.com/lordbasex/LordOS/tree/main/apps/mail), [apps/calendar](https://github.com/lordbasex/LordOS/tree/main/apps/calendar), [apps/contacts](https://github.com/lordbasex/LordOS/tree/main/apps/contacts), [apps/reminders](https://github.com/lordbasex/LordOS/tree/main/apps/reminders)
+- [server/tests/mail_test.c](https://github.com/lordbasex/LordOS/blob/main/server/tests/mail_test.c): os testes dos leitores e do sanitizador
+- [docs/MAIL.md](https://github.com/lordbasex/LordOS/blob/main/docs/MAIL.md)
diff --git a/web/content/features/own-desktop.en.md b/web/content/features/own-desktop.en.md
new file mode 100644
index 0000000..3955544
--- /dev/null
+++ b/web/content/features/own-desktop.en.md
@@ -0,0 +1,94 @@
+## The short version
+
+LordOS is a GNU/Linux distribution based on Debian 13. What makes it different is the desktop: instead of shipping GNOME or KDE, LordOS has a desktop environment of its own, built from its fundamental components on top of Debian and Wayland.
+
+Think of a house. Debian and the Linux kernel are the foundations, the plumbing and the wiring: they are reused, well tested and maintained by a large community. LordOS builds the rooms you actually live in: the screen you see, the windows you move, the apps you open and the guards at the doors.
+
+[[shot:0]]
+
+[[diagram:layers]]
+
+## What is ours and what is reused
+
+Being precise matters here, because "our own" is easy to overstate.
+
+**Written for LordOS (in this repository):**
+
+- **The display server and Wayland compositor** (`lord-server`, in C). It sets display modes with the kernel's DRM/KMS interface directly, without libdrm; reads keyboards, mice, touchpads and touchscreens from evdev, without libinput; composites every window; and speaks the Wayland protocol to Linux apps.
+- **The UI engine.** The desktop and the native apps are written in JavaScript with React. They run on QuickJS (a small JavaScript engine, vendored as source) inside `lord-server`, with a native node tree, a flexbox layout engine, a 2D rasterizer and a text engine written in C. There is no web browser engine behind the interface.
+- **The native apps:** Files, Settings, Terminal, Store, Mail, Calendar, Contacts, Reminders, Passwords, Monitor, Photos, Player, PDF Viewer, Disks, Backups and the rest, all React apps on the same engine.
+- **The security services:** the app sandbox launcher, the permission broker, the per-app permission store, the firewall service (`lord-netperm`), package signing and the password vault (`lord-vault`).
+- **System services** such as the session manager and login screen (`lord-sessiond`), the network service (`lord-netd`) and the fan service (`lord-fand`).
+
+**Reused from Debian and the free software world:**
+
+- the Linux kernel and Debian's packages (`dpkg` still unpacks and configures every package);
+- Mesa, for optional GPU composition;
+- PipeWire, for sound;
+- the Wayland protocol itself, through `libwayland-server` and `libwayland-client`;
+- `libxkbcommon` for keyboard layouts;
+- libraries used only inside sandboxed helper processes: FFmpeg (media), Poppler and libarchive (documents), OpenSSL (TLS for mail and remote desktop), Monocypher (the vault's cryptography).
+
+The rule the project follows is written down in `docs/ARCHITECTURE.md`: X11, wlroots, libdrm, libinput, WebKit, GTK and Qt are not used inside LordOS itself. GTK and Qt apps still run, as Wayland clients.
+
+## How a frame reaches the screen
+
+Here is what happens when you move the mouse over the Dock, step by step:
+
+1. The kernel delivers an input event through evdev. `lord-server` reads it and finds which node of the interface is under the pointer.
+2. It calls the JavaScript event handler. React updates its state and tells the engine which nodes changed: a style, a child, a text.
+3. The engine recomputes the layout and works out the damaged region: only the part of the screen that really changed.
+4. It repaints only that region, copies it to the back buffer, draws the cursor and flips the page on the next vertical blank.
+
+If a GPU with 3D acceleration is present, composition goes through Mesa (GBM, EGL and GLES2). If not, or if the only renderer is a software one, the CPU path does the work. The CPU path always has to keep working: it is a hard rule in the code (`LORD_GPU=0` forces it), and grub's "safe mode" boot entry uses it.
+
+[[diagram:frame]]
+
+## Where Linux apps plug in
+
+There are three kinds of windows on a LordOS desktop, and they connect at different layers:
+
+- **Built-in apps and the theme** (menu bar, Dock, Files, Settings…) run inside `lord-server`'s own JavaScript context, on the UI engine.
+- **Installed `.lpk` apps** each run as a separate process (`lord-server --app <id>`, the same binary in "app mode"). That process has its own copy of the UI engine, locks itself in a sandbox and draws into a shared-memory buffer, which it hands to the compositor as an ordinary Wayland client.
+- **Linux apps** (GTK, Qt, Chromium, Firefox…) connect to the compositor's Wayland socket. They draw themselves; the theme puts its window frame around them.
+
+So the compositor is the meeting point. The UI engine is used by LordOS's own interface and apps, not by Linux apps.
+
+[[shot:3]]
+
+## Light by design
+
+LordOS aims at modest machines. A few real measurements from the project's test logs:
+
+- The final 0.7.0 Beta ISO, idle a minute after login on a 4 GB, 4-core VM: **465 MB of RAM used** for the whole system in the live session and **487 MB** on the installed system, with the CPU **99 % idle**. Boot took 16.3 s (`docs/ISO.md`, "Final ISO test").
+- On a Raspberry Pi 5 (16 GB) at the login screen, without a monitor: `lord-server` at **36 MB RSS** and 0.6 % CPU (`docs/RASPBERRY.md`).
+- When the machine has no 3D-capable card, `lord-server` doesn't even load Mesa and stays at about 32 MB of RSS (`docs/GPU.md`).
+
+These numbers come from virtual machines and one board, not from a range of real PCs. They are a starting point, not a promise for every machine.
+
+[[shot:2]]
+
+## Many displays, sharp text
+
+The compositor drives several displays at once, extended or mirrored, and draws each one at its own scale: 100, 125, 150, 175 or 200 %. Text, vectors and images are rasterized at each display's real resolution, so a 4K panel at 150 % next to a 1080p one at 100 % is sharp on both. Linux apps get one `wl_output` per display and the fractional scale protocol, so GTK 4, Qt 6 and Chromium render sharp too.
+
+[[shot:1]]
+
+## Honest limits
+
+- **Real GPUs are not verified yet.** The GPU path was exercised with Mesa's software renderer in virtual machines. Testing on real AMD and Nvidia cards is still pending (`docs/GPU.md`).
+- **Multiple displays were tested with two virtual heads**, not with real monitors, laptop panels or DisplayPort hubs (`docs/DISPLAYS.md`).
+- **The Raspberry Pi 5 has not been tested with a monitor attached yet.** The build, the tests and the login screen ran on a real board without HDMI (`docs/RASPBERRY.md`).
+- **Xwayland is not part of LordOS**, so apps that only speak X11 don't run. Drag and drop between Linux apps, the primary selection and LordOS input methods inside Linux apps are pending (`docs/WAYLAND.md`).
+- **Accessibility is mostly ahead of us:** today there is a "reduce motion" setting; a screen reader, zoom and high contrast are on the roadmap.
+
+## Read the source
+
+- [docs/ARCHITECTURE.md](https://github.com/lordbasex/LordOS/blob/main/docs/ARCHITECTURE.md): the layers and the dependency policy
+- [server/src/kms.c](https://github.com/lordbasex/LordOS/blob/main/server/src/kms.c): modesetting with DRM ioctls, no libdrm
+- [server/src/input.c](https://github.com/lordbasex/LordOS/blob/main/server/src/input.c): evdev input
+- [server/src/gpu/gpu.c](https://github.com/lordbasex/LordOS/blob/main/server/src/gpu/gpu.c): optional GPU composition with Mesa
+- [server/src/ui/layout.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/layout.c) and [server/src/ui/paint.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/paint.c): layout and painting
+- [runtime/index.js](https://github.com/lordbasex/LordOS/blob/main/runtime/index.js): the React renderer for the native engine
+- [server/src/wl/wl.c](https://github.com/lordbasex/LordOS/blob/main/server/src/wl/wl.c): the Wayland compositor
+- [docs/GPU.md](https://github.com/lordbasex/LordOS/blob/main/docs/GPU.md), [docs/DISPLAYS.md](https://github.com/lordbasex/LordOS/blob/main/docs/DISPLAYS.md), [docs/ISO.md](https://github.com/lordbasex/LordOS/blob/main/docs/ISO.md)
diff --git a/web/content/features/own-desktop.es.md b/web/content/features/own-desktop.es.md
new file mode 100644
index 0000000..085a008
--- /dev/null
+++ b/web/content/features/own-desktop.es.md
@@ -0,0 +1,94 @@
+## En pocas palabras
+
+LordOS es una distribución GNU/Linux basada en Debian 13. Lo que la hace distinta es el escritorio: en lugar de traer GNOME o KDE, LordOS tiene un entorno de escritorio propio, construido desde sus componentes fundamentales sobre Debian y Wayland.
+
+Pensalo como una casa. Debian y el kernel Linux son los cimientos, las cañerías y la instalación eléctrica: se reutilizan, están muy probados y los mantiene una comunidad enorme. LordOS construye las habitaciones donde vivís de verdad: la pantalla que ves, las ventanas que movés, las apps que abrís y los guardias en las puertas.
+
+[[shot:0]]
+
+[[diagram:layers]]
+
+## Qué es propio y qué se reutiliza
+
+Acá conviene ser preciso, porque es fácil exagerar con "propio".
+
+**Escrito para LordOS (en este repositorio):**
+
+- **El servidor gráfico y compositor Wayland** (`lord-server`, en C). Configura los modos de pantalla directamente con la interfaz DRM/KMS del kernel, sin libdrm; lee teclados, mouse, touchpads y pantallas táctiles desde evdev, sin libinput; compone cada ventana; y habla el protocolo Wayland con las apps de Linux.
+- **El motor de interfaz.** El escritorio y las apps nativas están escritos en JavaScript con React. Corren sobre QuickJS (un motor de JavaScript chico, incluido como código fuente) dentro de `lord-server`, con un árbol de nodos nativo, un motor de layout flexbox, un rasterizador 2D y un motor de texto escritos en C. Detrás de la interfaz no hay ningún motor de navegador web.
+- **Las apps nativas:** Archivos, Ajustes, Terminal, Tienda, Mail, Calendario, Contactos, Recordatorios, Contraseñas, Monitor, Fotos, Reproductor, Visor de PDF, Discos, Copias de seguridad y el resto, todas apps React sobre el mismo motor.
+- **Los servicios de seguridad:** el lanzador de la caja de arena de las apps, el broker de permisos, el almacén de permisos por app, el servicio de firewall (`lord-netperm`), la firma de paquetes y la bóveda de contraseñas (`lord-vault`).
+- **Servicios del sistema** como el gestor de sesiones y la pantalla de ingreso (`lord-sessiond`), el servicio de red (`lord-netd`) y el de ventiladores (`lord-fand`).
+
+**Reutilizado de Debian y del mundo del software libre:**
+
+- el kernel Linux y los paquetes de Debian (`dpkg` sigue desempaquetando y configurando cada paquete);
+- Mesa, para la composición opcional en GPU;
+- PipeWire, para el sonido;
+- el propio protocolo Wayland, a través de `libwayland-server` y `libwayland-client`;
+- `libxkbcommon` para las distribuciones de teclado;
+- bibliotecas que se usan solo dentro de procesos ayudantes aislados: FFmpeg (multimedia), Poppler y libarchive (documentos), OpenSSL (TLS para el correo y el escritorio remoto), Monocypher (la criptografía de la bóveda).
+
+La regla que sigue el proyecto está escrita en `docs/ARCHITECTURE.md`: dentro de LordOS no se usan X11, wlroots, libdrm, libinput, WebKit, GTK ni Qt. Las apps GTK y Qt igual funcionan, como clientes Wayland.
+
+## Cómo llega un cuadro a la pantalla
+
+Esto es lo que pasa cuando pasás el mouse por el Dock, paso a paso:
+
+1. El kernel entrega un evento de entrada por evdev. `lord-server` lo lee y busca qué nodo de la interfaz está bajo el puntero.
+2. Llama al manejador de eventos de JavaScript. React actualiza su estado y le avisa al motor qué nodos cambiaron: un estilo, un hijo, un texto.
+3. El motor recalcula el layout y calcula la región dañada: solo la parte de la pantalla que de verdad cambió.
+4. Repinta solo esa región, la copia al buffer trasero, dibuja el cursor y cambia de página en el siguiente refresco vertical.
+
+Si hay una GPU con aceleración 3D, la composición pasa por Mesa (GBM, EGL y GLES2). Si no la hay, o si el único renderizador es uno por software, el trabajo lo hace el camino por CPU. El camino por CPU siempre tiene que seguir funcionando: es una regla firme del código (`LORD_GPU=0` lo fuerza), y la entrada "modo seguro" de grub lo usa.
+
+[[diagram:frame]]
+
+## Dónde se enchufan las apps de Linux
+
+En un escritorio LordOS hay tres tipos de ventanas, y se conectan en capas distintas:
+
+- **Las apps incluidas y el tema** (barra de menú, Dock, Archivos, Ajustes…) corren dentro del contexto de JavaScript del propio `lord-server`, sobre el motor de interfaz.
+- **Las apps `.lpk` instaladas** corren cada una como un proceso aparte (`lord-server --app <id>`, el mismo binario en "modo app"). Ese proceso tiene su propia copia del motor de interfaz, se encierra en una caja de arena y dibuja en un buffer de memoria compartida, que le pasa al compositor como un cliente Wayland común.
+- **Las apps de Linux** (GTK, Qt, Chromium, Firefox…) se conectan al socket Wayland del compositor. Se dibujan solas; el tema les pone su marco de ventana alrededor.
+
+O sea que el compositor es el punto de encuentro. El motor de interfaz lo usan la interfaz y las apps propias de LordOS, no las apps de Linux.
+
+[[shot:3]]
+
+## Liviano por diseño
+
+LordOS apunta a máquinas modestas. Algunas mediciones reales de los registros de prueba del proyecto:
+
+- La ISO final 0.7.0 Beta, en reposo un minuto después de ingresar, en una VM de 4 GB y 4 núcleos: **465 MB de RAM usados** por todo el sistema en la sesión live y **487 MB** en el sistema instalado, con la CPU **99 % ociosa**. El arranque tardó 16,3 s (`docs/ISO.md`, "Final ISO test").
+- En una Raspberry Pi 5 (16 GB) en la pantalla de ingreso, sin monitor: `lord-server` con **36 MB de RSS** y 0,6 % de CPU (`docs/RASPBERRY.md`).
+- Cuando la máquina no tiene una placa con 3D, `lord-server` ni siquiera carga Mesa y se queda en unos 32 MB de RSS (`docs/GPU.md`).
+
+Estos números salen de máquinas virtuales y de una sola placa, no de una variedad de PCs reales. Son un punto de partida, no una promesa para cualquier máquina.
+
+[[shot:2]]
+
+## Muchas pantallas, texto nítido
+
+El compositor maneja varias pantallas a la vez, extendidas o en espejo, y dibuja cada una con su propia escala: 100, 125, 150, 175 o 200 %. Texto, vectores e imágenes se rasterizan a la resolución real de cada pantalla, así que un panel 4K al 150 % al lado de uno 1080p al 100 % se ve nítido en los dos. Las apps de Linux reciben un `wl_output` por pantalla y el protocolo de escala fraccionaria, así que GTK 4, Qt 6 y Chromium también se ven nítidos.
+
+[[shot:1]]
+
+## Límites honestos
+
+- **Las GPU reales todavía no están verificadas.** El camino por GPU se probó con el renderizador por software de Mesa en máquinas virtuales. Falta probar en placas AMD y Nvidia reales (`docs/GPU.md`).
+- **Las pantallas múltiples se probaron con dos salidas virtuales**, no con monitores reales, paneles de notebook ni hubs DisplayPort (`docs/DISPLAYS.md`).
+- **La Raspberry Pi 5 todavía no se probó con un monitor conectado.** La compilación, las pruebas y la pantalla de ingreso corrieron en una placa real sin HDMI (`docs/RASPBERRY.md`).
+- **Xwayland no es parte de LordOS**, así que las apps que solo hablan X11 no funcionan. Arrastrar y soltar entre apps de Linux, la selección primaria y los métodos de entrada de LordOS dentro de apps de Linux están pendientes (`docs/WAYLAND.md`).
+- **La accesibilidad está mayormente por delante:** hoy hay un ajuste de "reducir movimiento"; un lector de pantalla, el zoom y el alto contraste están en la hoja de ruta.
+
+## Leé el código
+
+- [docs/ARCHITECTURE.md](https://github.com/lordbasex/LordOS/blob/main/docs/ARCHITECTURE.md): las capas y la política de dependencias
+- [server/src/kms.c](https://github.com/lordbasex/LordOS/blob/main/server/src/kms.c): modos de pantalla con ioctls de DRM, sin libdrm
+- [server/src/input.c](https://github.com/lordbasex/LordOS/blob/main/server/src/input.c): entrada por evdev
+- [server/src/gpu/gpu.c](https://github.com/lordbasex/LordOS/blob/main/server/src/gpu/gpu.c): composición opcional en GPU con Mesa
+- [server/src/ui/layout.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/layout.c) y [server/src/ui/paint.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/paint.c): layout y pintado
+- [runtime/index.js](https://github.com/lordbasex/LordOS/blob/main/runtime/index.js): el renderizador de React para el motor nativo
+- [server/src/wl/wl.c](https://github.com/lordbasex/LordOS/blob/main/server/src/wl/wl.c): el compositor Wayland
+- [docs/GPU.md](https://github.com/lordbasex/LordOS/blob/main/docs/GPU.md), [docs/DISPLAYS.md](https://github.com/lordbasex/LordOS/blob/main/docs/DISPLAYS.md), [docs/ISO.md](https://github.com/lordbasex/LordOS/blob/main/docs/ISO.md)
diff --git a/web/content/features/own-desktop.meta.json b/web/content/features/own-desktop.meta.json
new file mode 100644
index 0000000..79c12df
--- /dev/null
+++ b/web/content/features/own-desktop.meta.json
@@ -0,0 +1,335 @@
+{
+ "slug": "own-desktop",
+ "order": 1,
+ "title": {
+ "en": "A desktop of its own",
+ "es": "Un escritorio propio",
+ "pt": "Um desktop próprio"
+ },
+ "tagline": {
+ "en": "Its own display server, compositor and UI engine, built on solid Debian and Wayland foundations.",
+ "es": "Su propio servidor gráfico, compositor y motor de interfaz, sobre bases sólidas de Debian y Wayland.",
+ "pt": "Servidor gráfico, compositor e motor de interface próprios, sobre bases sólidas de Debian e Wayland."
+ },
+ "lumo": {
+ "pose": "wave",
+ "intro": {
+ "en": "Hi, I'm Lumo! Let me show you around the house. Debian and Linux are the foundations; the rooms you live in, from the screen to the windows to the apps, were built for LordOS.",
+ "es": "¡Hola, soy Lumo! Dejame mostrarte la casa. Debian y Linux son los cimientos; las habitaciones donde vivís, de la pantalla a las ventanas y las apps, se hicieron para LordOS.",
+ "pt": "Oi, eu sou o Lumo! Deixa eu te mostrar a casa. Debian e Linux são a fundação; os cômodos onde você vive, da tela às janelas e aos apps, foram feitos para o LordOS."
+ }
+ },
+ "screenshots": [
+ {
+ "file": "docs/screenshots/desktop-overview-light.png",
+ "caption": {
+ "en": "The LordOS desktop: menu bar, Dock and native apps, all drawn by its own engine.",
+ "es": "El escritorio de LordOS: barra de menús, Dock y apps nativas, todo dibujado por su propio motor.",
+ "pt": "O desktop do LordOS: barra de menus, Dock e apps nativos, tudo desenhado pelo motor próprio."
+ }
+ },
+ {
+ "file": "docs/displays-mixed-dpi.png",
+ "caption": {
+ "en": "Mixed scales: Settings spans a 100 % display and a 150 % one; each half is drawn at its display's resolution.",
+ "es": "Escalas mixtas: Ajustes ocupa una pantalla al 100 % y otra al 150 %; cada mitad se dibuja a la resolución de su pantalla.",
+ "pt": "Escalas mistas: Ajustes ocupa uma tela a 100 % e outra a 150 %; cada metade é desenhada na resolução da sua tela."
+ }
+ },
+ {
+ "file": "docs/iso-final/live-idle.png",
+ "caption": {
+ "en": "The 0.7.0 Beta live ISO at rest on a 4 GB VM: 465 MB used and a 16.3 s boot.",
+ "es": "La ISO live 0.7.0 Beta en reposo en una VM de 4 GB: 465 MB usados y un arranque de 16,3 s.",
+ "pt": "A ISO live 0.7.0 Beta em repouso numa VM de 4 GB: 465 MB em uso e boot de 16,3 s."
+ }
+ },
+ {
+ "file": "docs/wayland-three-apps-dock.png",
+ "caption": {
+ "en": "Three Linux apps open next to the native ones, each with its own icon in the Dock.",
+ "es": "Tres apps de Linux abiertas junto a las nativas, cada una con su ícono en el Dock.",
+ "pt": "Três apps Linux abertos ao lado dos nativos, cada um com seu ícone no Dock."
+ }
+ }
+ ],
+ "diagrams": [
+ {
+ "id": "layers",
+ "kind": "stack",
+ "title": {
+ "en": "The layers of LordOS",
+ "es": "Las capas de LordOS",
+ "pt": "As camadas do LordOS"
+ },
+ "nodes": [
+ {
+ "id": "apps",
+ "label": {
+ "en": "Apps",
+ "es": "Apps",
+ "pt": "Apps"
+ },
+ "sub": {
+ "en": "Built-in apps and the theme · isolated .lpk apps · Linux apps (GTK, Qt, browsers)",
+ "es": "Apps incluidas y el tema · apps .lpk aisladas · apps de Linux (GTK, Qt, navegadores)",
+ "pt": "Apps incluídos e o tema · apps .lpk isolados · apps Linux (GTK, Qt, navegadores)"
+ },
+ "tone": "user"
+ },
+ {
+ "id": "engine",
+ "label": {
+ "en": "LordOS UI engine",
+ "es": "Motor de interfaz de LordOS",
+ "pt": "Motor de interface do LordOS"
+ },
+ "sub": {
+ "en": "React on QuickJS, native layout, painting and text in C. Used by LordOS's own apps; Linux apps don't go through it",
+ "es": "React sobre QuickJS, layout, pintado y texto nativos en C. Lo usan las apps de LordOS; las apps de Linux no pasan por acá",
+ "pt": "React sobre QuickJS, layout, pintura e texto nativos em C. Usado pelos apps do LordOS; apps Linux não passam por ele"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "server",
+ "label": {
+ "en": "LordOS display server and Wayland compositor",
+ "es": "Servidor gráfico y compositor Wayland de LordOS",
+ "pt": "Servidor gráfico e compositor Wayland do LordOS"
+ },
+ "sub": {
+ "en": "lord-server, in C: KMS without libdrm, evdev without libinput, composition on CPU or GPU. Linux apps and isolated .lpk apps connect here as Wayland clients",
+ "es": "lord-server, en C: KMS sin libdrm, evdev sin libinput, composición en CPU o GPU. Las apps de Linux y las .lpk aisladas se conectan acá como clientes Wayland",
+ "pt": "lord-server, em C: KMS sem libdrm, evdev sem libinput, composição na CPU ou GPU. Apps Linux e apps .lpk isolados se conectam aqui como clientes Wayland"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "debian",
+ "label": {
+ "en": "Debian 13 userland",
+ "es": "Espacio de usuario de Debian 13",
+ "pt": "Espaço de usuário do Debian 13"
+ },
+ "sub": {
+ "en": "dpkg and packages, Mesa (optional GPU), PipeWire, libwayland, libxkbcommon, systemd",
+ "es": "dpkg y paquetes, Mesa (GPU opcional), PipeWire, libwayland, libxkbcommon, systemd",
+ "pt": "dpkg e pacotes, Mesa (GPU opcional), PipeWire, libwayland, libxkbcommon, systemd"
+ },
+ "tone": "reused"
+ },
+ {
+ "id": "kernel",
+ "label": {
+ "en": "Linux kernel",
+ "es": "Kernel Linux",
+ "pt": "Kernel Linux"
+ },
+ "sub": {
+ "en": "DRM/KMS, evdev, Landlock, seccomp, cgroups v2, eBPF",
+ "es": "DRM/KMS, evdev, Landlock, seccomp, cgroups v2, eBPF",
+ "pt": "DRM/KMS, evdev, Landlock, seccomp, cgroups v2, eBPF"
+ },
+ "tone": "kernel"
+ }
+ ],
+ "edges": [],
+ "caption": {
+ "en": "Violet layers are LordOS's own code; the lower layers are reused from Debian and Linux.",
+ "es": "Las capas violetas son código propio de LordOS; las de abajo se reutilizan de Debian y Linux.",
+ "pt": "As camadas violeta são código próprio do LordOS; as de baixo são reaproveitadas do Debian e do Linux."
+ }
+ },
+ {
+ "id": "frame",
+ "kind": "flow",
+ "title": {
+ "en": "From a mouse move to a new frame",
+ "es": "De un movimiento del mouse a un cuadro nuevo",
+ "pt": "De um movimento do mouse a um novo quadro"
+ },
+ "nodes": [
+ {
+ "id": "input",
+ "label": {
+ "en": "evdev event",
+ "es": "Evento evdev",
+ "pt": "Evento evdev"
+ },
+ "sub": {
+ "en": "From the kernel",
+ "es": "Desde el kernel",
+ "pt": "Do kernel"
+ },
+ "tone": "kernel"
+ },
+ {
+ "id": "hit",
+ "label": {
+ "en": "Hit test",
+ "es": "Búsqueda del nodo",
+ "pt": "Teste de clique"
+ },
+ "sub": {
+ "en": "Which node is under the pointer",
+ "es": "Qué nodo está bajo el puntero",
+ "pt": "Qual nó está sob o ponteiro"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "react",
+ "label": {
+ "en": "React update",
+ "es": "Actualización de React",
+ "pt": "Atualização do React"
+ },
+ "sub": {
+ "en": "Only changed nodes are marked",
+ "es": "Solo se marcan los nodos que cambiaron",
+ "pt": "Só os nós alterados são marcados"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "paint",
+ "label": {
+ "en": "Layout and paint",
+ "es": "Layout y pintado",
+ "pt": "Layout e pintura"
+ },
+ "sub": {
+ "en": "Only the damaged region",
+ "es": "Solo la región dañada",
+ "pt": "Só a região alterada"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "flip",
+ "label": {
+ "en": "Page flip",
+ "es": "Cambio de página",
+ "pt": "Troca de página"
+ },
+ "sub": {
+ "en": "On the next vblank, CPU or GPU path",
+ "es": "En el próximo vblank, por CPU o GPU",
+ "pt": "No próximo vblank, via CPU ou GPU"
+ },
+ "tone": "kernel"
+ }
+ ],
+ "edges": [
+ {
+ "from": "input",
+ "to": "hit",
+ "label": {
+ "en": "read",
+ "es": "lectura",
+ "pt": "leitura"
+ }
+ },
+ {
+ "from": "hit",
+ "to": "react",
+ "label": {
+ "en": "JS event",
+ "es": "evento JS",
+ "pt": "evento JS"
+ }
+ },
+ {
+ "from": "react",
+ "to": "paint",
+ "label": {
+ "en": "styles, children, text",
+ "es": "estilos, hijos, texto",
+ "pt": "estilos, filhos, texto"
+ }
+ },
+ {
+ "from": "paint",
+ "to": "flip",
+ "label": {
+ "en": "back buffer",
+ "es": "buffer trasero",
+ "pt": "buffer traseiro"
+ }
+ }
+ ],
+ "caption": {
+ "en": "The engine repaints only what changed, then flips the page on the next vertical blank.",
+ "es": "El motor repinta solo lo que cambió y cambia de página en el siguiente refresco vertical.",
+ "pt": "O motor repinta só o que mudou e troca a página no próximo retraço vertical."
+ }
+ }
+ ],
+ "sources": [
+ {
+ "path": "docs/ARCHITECTURE.md",
+ "what": {
+ "en": "Layers and dependency policy",
+ "es": "Capas y política de dependencias",
+ "pt": "Camadas e política de dependências"
+ }
+ },
+ {
+ "path": "server/src/kms.c",
+ "what": {
+ "en": "Modesetting with DRM ioctls, no libdrm",
+ "es": "Modos de pantalla con ioctls de DRM, sin libdrm",
+ "pt": "Modos de tela com ioctls DRM, sem libdrm"
+ }
+ },
+ {
+ "path": "server/src/input.c",
+ "what": {
+ "en": "evdev input",
+ "es": "Entrada por evdev",
+ "pt": "Entrada via evdev"
+ }
+ },
+ {
+ "path": "server/src/gpu/gpu.c",
+ "what": {
+ "en": "Optional GPU composition (Mesa)",
+ "es": "Composición opcional en GPU (Mesa)",
+ "pt": "Composição opcional na GPU (Mesa)"
+ }
+ },
+ {
+ "path": "server/src/ui/layout.c",
+ "what": {
+ "en": "Flexbox layout engine",
+ "es": "Motor de layout flexbox",
+ "pt": "Motor de layout flexbox"
+ }
+ },
+ {
+ "path": "server/src/ui/paint.c",
+ "what": {
+ "en": "Painting and damage",
+ "es": "Pintado y daño",
+ "pt": "Pintura e regiões alteradas"
+ }
+ },
+ {
+ "path": "runtime/index.js",
+ "what": {
+ "en": "React renderer for the native engine",
+ "es": "Renderizador de React para el motor nativo",
+ "pt": "Renderizador React para o motor nativo"
+ }
+ },
+ {
+ "path": "server/src/wl/wl.c",
+ "what": {
+ "en": "The Wayland compositor",
+ "es": "El compositor Wayland",
+ "pt": "O compositor Wayland"
+ }
+ }
+ ]
+}
diff --git a/web/content/features/own-desktop.pt.md b/web/content/features/own-desktop.pt.md
new file mode 100644
index 0000000..6614803
--- /dev/null
+++ b/web/content/features/own-desktop.pt.md
@@ -0,0 +1,94 @@
+## Em poucas palavras
+
+O LordOS é uma distribuição GNU/Linux baseada no Debian 13. O que o torna diferente é o desktop: em vez de trazer o GNOME ou o KDE, o LordOS tem um ambiente de desktop próprio, construído a partir dos seus componentes fundamentais sobre o Debian e o Wayland.
+
+[[shot:0]]
+
+Pense numa casa. O Debian e o kernel Linux são a fundação, o encanamento e a fiação: são reaproveitados, bem testados e mantidos por uma grande comunidade. O LordOS constrói os cômodos onde você de fato vive: a tela que você vê, as janelas que você move, os apps que você abre e os guardas nas portas.
+
+[[diagram:layers]]
+
+## O que é nosso e o que é reaproveitado
+
+Aqui a precisão importa, porque é fácil exagerar no "próprio".
+
+**Escrito para o LordOS (neste repositório):**
+
+- **O servidor gráfico e compositor Wayland** (`lord-server`, em C). Ele define os modos de tela usando diretamente a interface DRM/KMS do kernel, sem libdrm; lê teclados, mouses, touchpads e telas sensíveis ao toque pelo evdev, sem libinput; compõe todas as janelas; e fala o protocolo Wayland com os apps Linux.
+- **O motor de interface.** O desktop e os apps nativos são escritos em JavaScript com React. Eles rodam no QuickJS (um motor JavaScript pequeno, incluído como código-fonte) dentro do `lord-server`, com uma árvore de nós nativa, um motor de layout flexbox, um rasterizador 2D e um motor de texto escritos em C. Não há nenhum motor de navegador web por trás da interface.
+- **Os apps nativos:** Arquivos, Ajustes, Terminal, Loja, E-mail, Calendário, Contatos, Lembretes, Senhas, Monitor, Fotos, Player, Visualizador de PDF, Discos, Backups e os demais, todos apps React no mesmo motor.
+- **Os serviços de segurança:** o lançador de sandbox dos apps, o broker de permissões, o armazenamento de permissões por app, o serviço de firewall (`lord-netperm`), a assinatura de pacotes e o cofre de senhas (`lord-vault`).
+- **Serviços do sistema** como o gerenciador de sessões e a tela de login (`lord-sessiond`), o serviço de rede (`lord-netd`) e o serviço de ventoinhas (`lord-fand`).
+
+**Reaproveitado do Debian e do mundo do software livre:**
+
+- o kernel Linux e os pacotes do Debian (o `dpkg` continua desempacotando e configurando cada pacote);
+- o Mesa, para a composição opcional na GPU;
+- o PipeWire, para o som;
+- o próprio protocolo Wayland, via `libwayland-server` e `libwayland-client`;
+- a `libxkbcommon`, para os layouts de teclado;
+- bibliotecas usadas só dentro de processos ajudantes em sandbox: FFmpeg (mídia), Poppler e libarchive (documentos), OpenSSL (TLS para e-mail e área de trabalho remota), Monocypher (a criptografia do cofre).
+
+A regra que o projeto segue está escrita em `docs/ARCHITECTURE.md`: X11, wlroots, libdrm, libinput, WebKit, GTK e Qt não são usados dentro do próprio LordOS. Apps GTK e Qt continuam rodando, como clientes Wayland.
+
+## Como um quadro chega à tela
+
+Veja o que acontece, passo a passo, quando você passa o mouse sobre o Dock:
+
+1. O kernel entrega um evento de entrada pelo evdev. O `lord-server` o lê e descobre qual nó da interface está sob o ponteiro.
+2. Ele chama o tratador de eventos em JavaScript. O React atualiza seu estado e informa ao motor quais nós mudaram: um estilo, um filho, um texto.
+3. O motor recalcula o layout e determina a região alterada: só a parte da tela que realmente mudou.
+4. Ele repinta só essa região, copia para o buffer traseiro, desenha o cursor e troca a página no próximo retraço vertical.
+
+Se houver uma GPU com aceleração 3D, a composição passa pelo Mesa (GBM, EGL e GLES2). Se não houver, ou se o único renderizador for por software, o caminho da CPU faz o trabalho. O caminho da CPU precisa continuar funcionando sempre: é uma regra rígida no código (`LORD_GPU=0` o força), e a opção "modo seguro" do grub usa esse caminho.
+
+[[diagram:frame]]
+
+## Onde os apps Linux se encaixam
+
+Há três tipos de janela num desktop LordOS, e elas se conectam em camadas diferentes:
+
+- **Os apps incluídos e o tema** (barra de menus, Dock, Arquivos, Ajustes…) rodam dentro do próprio contexto JavaScript do `lord-server`, no motor de interface.
+- **Os apps `.lpk` instalados** rodam cada um como um processo separado (`lord-server --app <id>`, o mesmo binário em "modo app"). Esse processo tem sua própria cópia do motor de interface, se tranca num sandbox e desenha num buffer de memória compartilhada, que entrega ao compositor como um cliente Wayland comum.
+- **Os apps Linux** (GTK, Qt, Chromium, Firefox…) se conectam ao socket Wayland do compositor. Eles se desenham sozinhos; o tema coloca sua moldura de janela em volta deles.
+
+Ou seja, o compositor é o ponto de encontro. O motor de interface é usado pela interface e pelos apps do próprio LordOS, não pelos apps Linux.
+
+[[shot:3]]
+
+## Leve por projeto
+
+O LordOS mira máquinas modestas. Algumas medições reais dos registros de teste do projeto:
+
+- A ISO final 0.7.0 Beta, ociosa um minuto após o login numa VM com 4 GB e 4 núcleos: **465 MB de RAM em uso** para o sistema inteiro na sessão live e **487 MB** no sistema instalado, com a CPU **99 % ociosa**. O boot levou 16,3 s (`docs/ISO.md`, "Final ISO test").
+- Num Raspberry Pi 5 (16 GB), na tela de login e sem monitor: `lord-server` com **36 MB de RSS** e 0,6 % de CPU (`docs/RASPBERRY.md`).
+- Quando a máquina não tem placa com 3D, o `lord-server` nem carrega o Mesa e fica em torno de 32 MB de RSS (`docs/GPU.md`).
+
+Esses números vêm de máquinas virtuais e de uma placa, não de uma variedade de PCs reais. São um ponto de partida, não uma promessa para toda máquina.
+
+[[shot:2]]
+
+## Várias telas, texto nítido
+
+O compositor controla várias telas ao mesmo tempo, estendidas ou espelhadas, e desenha cada uma na sua própria escala: 100, 125, 150, 175 ou 200 %. Texto, vetores e imagens são rasterizados na resolução real de cada tela, então um painel 4K a 150 % ao lado de um 1080p a 100 % fica nítido nos dois. Os apps Linux recebem um `wl_output` por tela e o protocolo de escala fracionária, então GTK 4, Qt 6 e Chromium também renderizam com nitidez.
+
+[[shot:1]]
+
+## Limites honestos
+
+- **GPUs reais ainda não foram verificadas.** O caminho da GPU foi exercitado com o renderizador por software do Mesa em máquinas virtuais. O teste em placas AMD e Nvidia reais ainda está pendente (`docs/GPU.md`).
+- **Várias telas foram testadas com duas saídas virtuais**, não com monitores reais, painéis de notebook ou hubs DisplayPort (`docs/DISPLAYS.md`).
+- **O Raspberry Pi 5 ainda não foi testado com um monitor conectado.** A compilação, os testes e a tela de login rodaram numa placa real sem HDMI (`docs/RASPBERRY.md`).
+- **O Xwayland não faz parte do LordOS**, então apps que só falam X11 não rodam. Arrastar e soltar entre apps Linux, a seleção primária e os métodos de entrada do LordOS dentro de apps Linux estão pendentes (`docs/WAYLAND.md`).
+- **A acessibilidade ainda está quase toda pela frente:** hoje existe um ajuste para "reduzir movimento"; leitor de tela, zoom e alto contraste estão no roadmap.
+
+## Leia o código
+
+- [docs/ARCHITECTURE.md](https://github.com/lordbasex/LordOS/blob/main/docs/ARCHITECTURE.md): as camadas e a política de dependências
+- [server/src/kms.c](https://github.com/lordbasex/LordOS/blob/main/server/src/kms.c): modos de tela com ioctls DRM, sem libdrm
+- [server/src/input.c](https://github.com/lordbasex/LordOS/blob/main/server/src/input.c): entrada via evdev
+- [server/src/gpu/gpu.c](https://github.com/lordbasex/LordOS/blob/main/server/src/gpu/gpu.c): composição opcional na GPU com Mesa
+- [server/src/ui/layout.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/layout.c) e [server/src/ui/paint.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/paint.c): layout e pintura
+- [runtime/index.js](https://github.com/lordbasex/LordOS/blob/main/runtime/index.js): o renderizador React para o motor nativo
+- [server/src/wl/wl.c](https://github.com/lordbasex/LordOS/blob/main/server/src/wl/wl.c): o compositor Wayland
+- [docs/GPU.md](https://github.com/lordbasex/LordOS/blob/main/docs/GPU.md), [docs/DISPLAYS.md](https://github.com/lordbasex/LordOS/blob/main/docs/DISPLAYS.md), [docs/ISO.md](https://github.com/lordbasex/LordOS/blob/main/docs/ISO.md)
diff --git a/web/content/features/passwords.en.md b/web/content/features/passwords.en.md
new file mode 100644
index 0000000..0bd46f7
--- /dev/null
+++ b/web/content/features/passwords.en.md
@@ -0,0 +1,79 @@
+## The short version
+
+Passwords is LordOS's password manager, and the same machinery is the **system keyring**: the place where apps keep secrets such as Wi-Fi passwords, VPN credentials and mail account passwords. Everything is stored in an encrypted vault file, and everything that touches your secrets in plain form runs in one small locked-in process, `lord-vault`.
+
+[[shot:0]]
+
+Think of a safe-deposit room in a bank. The Passwords window is the counter where you talk; `lord-vault` is the vault behind the wall. The clerk (`lord-server`) passes documents through a slot, but never holds the key. Only what you ask to see is brought out, one item at a time.
+
+[[diagram:vault]]
+
+## What it does
+
+- **Items for everything:** websites, cards, Wi-Fi (with a QR code to join from a phone), servers and SSH keys, licences with their files, identity documents with photos, crypto wallets with an extra warning, secure notes. Sixteen built-in categories, plus your own, in a tree, with tags.
+- **2FA codes** (TOTP and HOTP) with a live countdown. You can add one from a QR image; the secret never leaves `lord-vault`, and the window only receives the current code.
+- **A generator** for passwords and passphrases from a 7,776-word list.
+- **A security report** with weak, reused, old and breached passwords. "Breached" is checked **offline only**: against a bundled list of 10,000 common passwords and, if you provide one, a local file of breached-password hashes. Nothing is ever looked up online; `lord-vault` has no network at all.
+- **Import** from KDBX files (versions 3.1 and 4), from browser CSV exports and from other managers' CSV and JSON exports, with LordOS's own readers. **Export** to an encrypted copy, or to CSV after a red warning.
+
+[[shot:3]]
+
+## How you unlock it
+
+The vault has one random 32-byte key. It is never derived from your password. Instead, each way of unlocking wraps that same key:
+
+- **a master password**, stretched with Argon2id, with its cost measured on your machine to take about 0.7 s;
+- **a FIDO2 security key** with the `hmac-secret` extension, through LordOS's own CTAP2 client;
+- **a key file**, for example on a USB stick;
+- **a password plus a key file**, as two factors;
+- **a printable recovery key** of 40 characters.
+
+Several methods can live side by side. The vault locks itself after 5 minutes of inactivity by default, when you lock the screen and when you switch users.
+
+[[shot:1]]
+
+## How it protects your secrets
+
+**The file.** A single `.lvault` file, encrypted with XChaCha20-Poly1305. The header is authenticated together with the body, so changing any byte, swapping an unlock slot or truncating the file is detected. The test suite flips every byte of a vault and checks that each one is caught: 1,165 of 1,165. Saving is atomic, with a `.bak` of the previous version.
+
+**The process.** `lord-vault` is started by `lord-server` with a fixed path and no arguments, and locks itself in before reading anything: no network, no new sockets, no running programs, no files except the vault folder it receives already open. It can't be debugged or dumped by other processes of your user, and secrets live in locked memory (`mlock`) that is excluded from core dumps and wiped when freed.
+
+**The window.** The Passwords window itself runs as its own sandboxed process (`lord-server --app passwords`), not in the desktop's JavaScript. Revealed values never enter the desktop's memory. Lists show titles and user names, never secrets; a value travels only when you click reveal, copy or edit.
+
+**The screen.** The Passwords window is protected: it comes out black in screenshots, screen recordings and the remote desktop.
+
+**The clipboard.** A copied secret stays out of the clipboard history, is marked as sensitive for Linux apps that honour that convention, and is cleared after 30 seconds (configurable) if it is still there.
+
+[[shot:2]]
+
+## The system keyring
+
+- **Opened at login.** `lord-sessiond` checks your login password, then hands it once to `lord-vault` to open the session keyring, and wipes its copy.
+- **LordOS apps** keep their secrets with the SDK's `keyring`. Each app sees only its own items. For installed `.lpk` apps, `lord-server` sets the owner from the app's verified identity, so an app can't claim to be another. If an app asks for another app's item, the system asks you first.
+- **Linux apps** use the standard freedesktop Secret Service over D-Bus, served by LordOS's own code. Chromium was tested end to end: it saved a login, restarted, fetched its key from LordOS's keyring and filled the login in.
+
+[[shot:4]]
+
+## The skeptical reader's questions
+
+**Who can read the session keyring?** Inside LordOS, each app only its own items, unless you share one. Through the Secret Service, the access rule is the freedesktop one: any Linux app of your session that can reach the session bus can read the unlocked collection, as with other desktop keyrings. Isolated `.lpk` apps can't reach the bus.
+
+**Can the Passwords app read the security key directly?** No. Using a security key goes through the `usb` permission prompt; then `lord-server` opens the device and passes it straight to `lord-vault`. Neither the app window nor its JavaScript ever holds it.
+
+## Honest limits
+
+- **Real security keys haven't been tested.** The FIDO2 path was tested only against a software authenticator. Keys that verify only with a built-in fingerprint reader, and the newer PIN protocol 2, aren't supported.
+- **The Secret Service is minimal:** one collection, no per-app access rules, no delete prompts.
+- **The large Argon2 work area can't be locked in memory** under Debian's default limit; it is excluded from dumps and wiped after each use.
+- **Some KDBX variants aren't supported** (Twofish and Argon2 version 0x10).
+
+## Read the source
+
+- [server/src/vault/vault.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/vault.c): the `lord-vault` process and its sandbox
+- [server/src/vault/vfile.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/vfile.c): the `.lvault` format and unlock slots
+- [server/src/vault/smem.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/smem.c): the locked, wiped memory arena
+- [server/src/vault/keyring.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/keyring.c) and [server/src/vault/secretsvc.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/secretsvc.c): the keyring and the Secret Service
+- [server/src/vault/ctap2.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/ctap2.c): the FIDO2 client
+- [server/src/sec/brokerkr.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/brokerkr.c): the keyring for isolated apps
+- [apps/passwords](https://github.com/lordbasex/LordOS/tree/main/apps/passwords): the app
+- [docs/PASSWORDS.md](https://github.com/lordbasex/LordOS/blob/main/docs/PASSWORDS.md)
diff --git a/web/content/features/passwords.es.md b/web/content/features/passwords.es.md
new file mode 100644
index 0000000..62d1df0
--- /dev/null
+++ b/web/content/features/passwords.es.md
@@ -0,0 +1,79 @@
+## En pocas palabras
+
+Contraseñas es el gestor de contraseñas de LordOS, y la misma maquinaria es el **llavero del sistema**: el lugar donde las apps guardan secretos como contraseñas de Wi-Fi, credenciales de VPN y contraseñas de cuentas de correo. Todo se guarda en un archivo de bóveda cifrado, y todo lo que toca tus secretos en claro corre en un único proceso chico y encerrado, `lord-vault`.
+
+[[shot:0]]
+
+Pensalo como el sector de cajas de seguridad de un banco. La ventana de Contraseñas es el mostrador donde hablás; `lord-vault` es la bóveda detrás de la pared. El empleado (`lord-server`) pasa documentos por una ranura, pero nunca tiene la llave. Solo sale lo que pedís ver, de a un ítem por vez.
+
+[[diagram:vault]]
+
+## Qué hace
+
+- **Ítems para todo:** sitios web, tarjetas, Wi-Fi (con un código QR para conectarse desde un teléfono), servidores y claves SSH, licencias con sus archivos, documentos de identidad con fotos, billeteras cripto con una advertencia extra, notas seguras. Dieciséis categorías incluidas, más las tuyas, en árbol, con etiquetas.
+- **Códigos 2FA** (TOTP y HOTP) con cuenta regresiva en vivo. Podés agregar uno desde una imagen QR; el secreto nunca sale de `lord-vault` y la ventana solo recibe el código actual.
+- **Un generador** de contraseñas y de frases de contraseña a partir de una lista de 7776 palabras.
+- **Un informe de seguridad** con contraseñas débiles, repetidas, viejas y filtradas. "Filtradas" se revisa **solo sin conexión**: contra una lista incluida de las 10.000 contraseñas más comunes y, si le das uno, un archivo local de hashes de contraseñas filtradas. Nunca se consulta nada en línea; `lord-vault` no tiene red en absoluto.
+- **Importación** desde archivos KDBX (versiones 3.1 y 4), desde exportaciones CSV de navegadores y desde exportaciones CSV y JSON de otros gestores, con lectores propios de LordOS. **Exportación** a una copia cifrada, o a CSV después de una advertencia en rojo.
+
+[[shot:3]]
+
+## Cómo la desbloqueás
+
+La bóveda tiene una única clave aleatoria de 32 bytes. Nunca se deriva de tu contraseña. En cambio, cada forma de desbloqueo envuelve esa misma clave:
+
+- **una contraseña maestra**, estirada con Argon2id, con su costo medido en tu máquina para que tarde unos 0,7 s;
+- **una llave de seguridad FIDO2** con la extensión `hmac-secret`, a través del cliente CTAP2 propio de LordOS;
+- **un archivo llave**, por ejemplo en un pendrive;
+- **una contraseña más un archivo llave**, como dos factores;
+- **una clave de recuperación imprimible** de 40 caracteres.
+
+Varios métodos pueden convivir. Por defecto, la bóveda se cierra sola después de 5 minutos sin uso, cuando bloqueás la pantalla y cuando cambiás de usuario.
+
+[[shot:1]]
+
+## Cómo protege tus secretos
+
+**El archivo.** Un único archivo `.lvault`, cifrado con XChaCha20-Poly1305. El encabezado se autentica junto con el cuerpo, así que cambiar cualquier byte, intercambiar una ranura de desbloqueo o truncar el archivo se detecta. La batería de pruebas invierte cada byte de una bóveda y verifica que se detecte cada uno: 1165 de 1165. El guardado es atómico, con un `.bak` de la versión anterior.
+
+**El proceso.** `lord-server` arranca `lord-vault` desde una ruta fija y sin argumentos, y se encierra antes de leer nada: sin red, sin sockets nuevos, sin ejecutar programas, sin archivos salvo la carpeta de la bóveda que recibe ya abierta. Otros procesos de tu usuario no pueden depurarlo ni volcar su memoria, y los secretos viven en memoria bloqueada (`mlock`) que queda fuera de los volcados de memoria y se borra al liberarse.
+
+**La ventana.** La propia ventana de Contraseñas corre como su propio proceso aislado (`lord-server --app passwords`), no en el JavaScript del escritorio. Los valores revelados nunca entran en la memoria del escritorio. Las listas muestran títulos y nombres de usuario, nunca secretos; un valor viaja solo cuando tocás revelar, copiar o editar.
+
+**La pantalla.** La ventana de Contraseñas está protegida: sale en negro en las capturas, las grabaciones de pantalla y el escritorio remoto.
+
+**El portapapeles.** Un secreto copiado queda fuera del historial del portapapeles, se marca como sensible para las apps de Linux que respetan esa convención, y se borra a los 30 segundos (configurable) si todavía sigue ahí.
+
+[[shot:2]]
+
+## El llavero del sistema
+
+- **Se abre al ingresar.** `lord-sessiond` verifica tu contraseña de ingreso, se la pasa una sola vez a `lord-vault` para abrir el llavero de la sesión y borra su copia.
+- **Las apps de LordOS** guardan sus secretos con el `keyring` del SDK. Cada app ve solo sus propios ítems. Para las apps `.lpk` instaladas, `lord-server` fija el dueño a partir de la identidad verificada de la app, así que una app no puede hacerse pasar por otra. Si una app pide un ítem de otra app, el sistema primero te pregunta a vos.
+- **Las apps de Linux** usan el Secret Service estándar de freedesktop por D-Bus, servido por código propio de LordOS. Chromium se probó de punta a punta: guardó un login, se reinició, buscó su clave en el llavero de LordOS y completó el login.
+
+[[shot:4]]
+
+## Las preguntas del lector escéptico
+
+**¿Quién puede leer el llavero de la sesión?** Dentro de LordOS, cada app solo sus propios ítems, salvo que compartas uno. Por el Secret Service, la regla de acceso es la de freedesktop: cualquier app de Linux de tu sesión que llegue al bus de la sesión puede leer la colección desbloqueada, como con otros llaveros de escritorio. Las apps `.lpk` aisladas no llegan al bus.
+
+**¿La app Contraseñas puede leer la llave de seguridad directamente?** No. Usar una llave de seguridad pasa por el aviso del permiso `usb`; después `lord-server` abre el dispositivo y se lo pasa directo a `lord-vault`. Ni la ventana de la app ni su JavaScript lo tienen nunca.
+
+## Límites honestos
+
+- **No se probaron llaves de seguridad reales.** El camino FIDO2 se probó solo contra un autenticador por software. Las llaves que solo verifican con un lector de huellas incorporado, y el protocolo de PIN 2 más nuevo, no están soportados.
+- **El Secret Service es mínimo:** una sola colección, sin reglas de acceso por app, sin avisos al borrar.
+- **El área de trabajo grande de Argon2 no se puede bloquear en memoria** con el límite predeterminado de Debian; queda fuera de los volcados y se borra después de cada uso.
+- **Algunas variantes de KDBX no están soportadas** (Twofish y Argon2 versión 0x10).
+
+## Leé el código
+
+- [server/src/vault/vault.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/vault.c): el proceso `lord-vault` y su caja de arena
+- [server/src/vault/vfile.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/vfile.c): el formato `.lvault` y las ranuras de desbloqueo
+- [server/src/vault/smem.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/smem.c): la zona de memoria bloqueada y borrada
+- [server/src/vault/keyring.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/keyring.c) y [server/src/vault/secretsvc.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/secretsvc.c): el llavero y el Secret Service
+- [server/src/vault/ctap2.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/ctap2.c): el cliente FIDO2
+- [server/src/sec/brokerkr.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/brokerkr.c): el llavero para apps aisladas
+- [apps/passwords](https://github.com/lordbasex/LordOS/tree/main/apps/passwords): la app
+- [docs/PASSWORDS.md](https://github.com/lordbasex/LordOS/blob/main/docs/PASSWORDS.md)
diff --git a/web/content/features/passwords.meta.json b/web/content/features/passwords.meta.json
new file mode 100644
index 0000000..5d62723
--- /dev/null
+++ b/web/content/features/passwords.meta.json
@@ -0,0 +1,233 @@
+{
+ "slug": "passwords",
+ "order": 4,
+ "title": {
+ "en": "Passwords built in",
+ "es": "Contraseñas incluidas",
+ "pt": "Senhas integradas"
+ },
+ "tagline": {
+ "en": "An encrypted vault for passwords, 2FA codes and cards, and the system keyring, in a locked-in helper.",
+ "es": "Una bóveda cifrada para contraseñas, códigos 2FA y tarjetas, y el llavero del sistema, en un ayudante encerrado.",
+ "pt": "Um cofre criptografado para senhas, códigos 2FA e cartões, e o chaveiro do sistema, num ajudante isolado."
+ },
+ "lumo": {
+ "pose": "sleep",
+ "intro": {
+ "en": "Shh, the vault is sleeping. That's a good thing: when nobody uses it, it locks itself. When you need a password, wake it with yours or with your security key, and I'll bring out just that one.",
+ "es": "Shh, la bóveda está durmiendo. Y está bien: cuando nadie la usa, se cierra sola. Cuando necesites una contraseña, despertala con la tuya o con tu llave de seguridad, y te traigo solo esa.",
+ "pt": "Psiu, o cofre está dormindo. E isso é bom: quando ninguém usa, ele se tranca sozinho. Quando você precisar de uma senha, acorde-o com a sua ou com sua chave de segurança, e eu trago só aquela."
+ }
+ },
+ "screenshots": [
+ {
+ "file": "docs/passwords-internet.png",
+ "caption": {
+ "en": "A website item: user, hidden password, live 2FA code and a change reminder.",
+ "es": "Un ítem de sitio web: usuario, contraseña oculta, código 2FA en vivo y un recordatorio de cambio.",
+ "pt": "Um item de site: usuário, senha oculta, código 2FA ao vivo e um lembrete de troca."
+ }
+ },
+ {
+ "file": "docs/passwords-settings.png",
+ "caption": {
+ "en": "Unlock methods side by side: password, recovery key, security key and key file, each wrapping the same vault key.",
+ "es": "Métodos de desbloqueo lado a lado: contraseña, clave de recuperación, llave de seguridad y archivo llave, cada uno envuelve la misma clave de la bóveda.",
+ "pt": "Métodos de desbloqueio lado a lado: senha, chave de recuperação, chave de segurança e arquivo-chave, cada um envolvendo a mesma chave do cofre."
+ }
+ },
+ {
+ "file": "docs/passwords-protected-capture.png",
+ "caption": {
+ "en": "The Passwords window comes out black in LordOS screenshots, recordings and the remote desktop.",
+ "es": "La ventana de Contraseñas sale en negro en las capturas, grabaciones y el escritorio remoto de LordOS.",
+ "pt": "A janela de Senhas sai preta nas capturas, gravações e na área de trabalho remota do LordOS."
+ }
+ },
+ {
+ "file": "docs/passwords-2fa.png",
+ "caption": {
+ "en": "Every 2FA code with its countdown; the secrets stay inside lord-vault.",
+ "es": "Todos los códigos 2FA con su cuenta regresiva; los secretos se quedan dentro de lord-vault.",
+ "pt": "Todos os códigos 2FA com contagem regressiva; os segredos ficam dentro do lord-vault."
+ }
+ },
+ {
+ "file": "docs/passwords-browser-autofill.png",
+ "caption": {
+ "en": "A Linux browser fills in a saved login with its key from LordOS's keyring.",
+ "es": "Un navegador de Linux completa un login guardado con su clave del llavero de LordOS.",
+ "pt": "Um navegador Linux preenche um login salvo com a chave do chaveiro do LordOS."
+ }
+ }
+ ],
+ "diagrams": [
+ {
+ "id": "vault",
+ "kind": "flow",
+ "title": {
+ "en": "Where your secrets live",
+ "es": "Dónde viven tus secretos",
+ "pt": "Onde seus segredos vivem"
+ },
+ "nodes": [
+ {
+ "id": "ui",
+ "label": {
+ "en": "Passwords window",
+ "es": "Ventana de Contraseñas",
+ "pt": "Janela de Senhas"
+ },
+ "sub": {
+ "en": "Its own sandboxed process; protected from capture",
+ "es": "Su propio proceso aislado; protegida de capturas",
+ "pt": "Processo próprio em sandbox; protegida contra capturas"
+ },
+ "tone": "user"
+ },
+ {
+ "id": "server",
+ "label": {
+ "en": "lord-server",
+ "es": "lord-server",
+ "pt": "lord-server"
+ },
+ "sub": {
+ "en": "Opens files and devices, relays; never holds the vault key",
+ "es": "Abre archivos y dispositivos, retransmite; nunca tiene la clave de la bóveda",
+ "pt": "Abre arquivos e dispositivos, repassa; nunca tem a chave do cofre"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "vault",
+ "label": {
+ "en": "lord-vault",
+ "es": "lord-vault",
+ "pt": "lord-vault"
+ },
+ "sub": {
+ "en": "No network, no sockets, no exec; secrets in locked memory",
+ "es": "Sin red, sin sockets, sin exec; secretos en memoria bloqueada",
+ "pt": "Sem rede, sem sockets, sem exec; segredos em memória travada"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "file",
+ "label": {
+ "en": ".lvault file",
+ "es": "Archivo .lvault",
+ "pt": "Arquivo .lvault"
+ },
+ "sub": {
+ "en": "XChaCha20-Poly1305; header authenticated",
+ "es": "XChaCha20-Poly1305; encabezado autenticado",
+ "pt": "XChaCha20-Poly1305; cabeçalho autenticado"
+ },
+ "tone": "kernel"
+ }
+ ],
+ "edges": [
+ {
+ "from": "ui",
+ "to": "server",
+ "label": {
+ "en": "own channel",
+ "es": "canal propio",
+ "pt": "canal próprio"
+ }
+ },
+ {
+ "from": "server",
+ "to": "vault",
+ "label": {
+ "en": "file descriptors",
+ "es": "descriptores de archivo",
+ "pt": "descritores de arquivo"
+ }
+ },
+ {
+ "from": "vault",
+ "to": "file",
+ "label": {
+ "en": "vault folder only",
+ "es": "solo la carpeta de la bóveda",
+ "pt": "só a pasta do cofre"
+ }
+ }
+ ],
+ "caption": {
+ "en": "Plain-text secrets exist only in the Passwords window process and in lord-vault, and only when you ask for them.",
+ "es": "Los secretos en claro existen solo en el proceso de la ventana de Contraseñas y en lord-vault, y solo cuando los pedís.",
+ "pt": "Segredos em texto puro só existem no processo da janela de Senhas e no lord-vault, e só quando você pede."
+ }
+ }
+ ],
+ "sources": [
+ {
+ "path": "server/src/vault/vault.c",
+ "what": {
+ "en": "The lord-vault process",
+ "es": "El proceso lord-vault",
+ "pt": "O processo lord-vault"
+ }
+ },
+ {
+ "path": "server/src/vault/vfile.c",
+ "what": {
+ "en": "The .lvault format",
+ "es": "El formato .lvault",
+ "pt": "O formato .lvault"
+ }
+ },
+ {
+ "path": "server/src/vault/smem.c",
+ "what": {
+ "en": "Locked, wiped memory",
+ "es": "Memoria bloqueada y borrada",
+ "pt": "Memória travada e apagada"
+ }
+ },
+ {
+ "path": "server/src/vault/keyring.c",
+ "what": {
+ "en": "The session keyring",
+ "es": "El llavero de la sesión",
+ "pt": "O chaveiro da sessão"
+ }
+ },
+ {
+ "path": "server/src/vault/secretsvc.c",
+ "what": {
+ "en": "The Secret Service on D-Bus",
+ "es": "El Secret Service en D-Bus",
+ "pt": "O Secret Service no D-Bus"
+ }
+ },
+ {
+ "path": "server/src/vault/ctap2.c",
+ "what": {
+ "en": "The FIDO2 client",
+ "es": "El cliente FIDO2",
+ "pt": "O cliente FIDO2"
+ }
+ },
+ {
+ "path": "server/src/sec/brokerkr.c",
+ "what": {
+ "en": "Keyring for isolated apps",
+ "es": "Llavero para apps aisladas",
+ "pt": "Chaveiro para apps isolados"
+ }
+ },
+ {
+ "path": "docs/PASSWORDS.md",
+ "what": {
+ "en": "Full design and tests",
+ "es": "Diseño completo y pruebas",
+ "pt": "Projeto completo e testes"
+ }
+ }
+ ]
+}
diff --git a/web/content/features/passwords.pt.md b/web/content/features/passwords.pt.md
new file mode 100644
index 0000000..089bf06
--- /dev/null
+++ b/web/content/features/passwords.pt.md
@@ -0,0 +1,79 @@
+## Em poucas palavras
+
+Senhas é o gerenciador de senhas do LordOS, e a mesma engrenagem é o **chaveiro do sistema**: o lugar onde os apps guardam segredos como senhas de Wi-Fi, credenciais de VPN e senhas de contas de e-mail. Tudo fica num arquivo de cofre criptografado, e tudo o que toca seus segredos em texto puro roda num único processo pequeno e trancado, o `lord-vault`.
+
+[[shot:0]]
+
+Pense na sala de cofres de um banco. A janela de Senhas é o balcão onde você conversa; o `lord-vault` é o cofre atrás da parede. O atendente (`lord-server`) passa os documentos por uma fresta, mas nunca segura a chave. Só sai o que você pede para ver, um item por vez.
+
+[[diagram:vault]]
+
+## O que ele faz
+
+- **Itens para tudo:** sites, cartões, Wi-Fi (com um QR code para entrar pelo celular), servidores e chaves SSH, licenças com seus arquivos, documentos de identidade com fotos, carteiras de cripto com um aviso extra, notas seguras. Dezesseis categorias de fábrica, mais as suas, em árvore, com tags.
+- **Códigos 2FA** (TOTP e HOTP) com contagem regressiva ao vivo. Dá para adicionar um a partir de uma imagem de QR; o segredo nunca sai do `lord-vault`, e a janela só recebe o código atual.
+- **Um gerador** de senhas e de frases-senha a partir de uma lista de 7.776 palavras.
+- **Um relatório de segurança** com senhas fracas, reutilizadas, antigas e vazadas. "Vazada" é verificado **só offline**: contra uma lista incluída de 10.000 senhas comuns e, se você fornecer, um arquivo local de hashes de senhas vazadas. Nada é consultado online; o `lord-vault` não tem rede nenhuma.
+- **Importação** de arquivos KDBX (versões 3.1 e 4), de exportações CSV de navegadores e de exportações CSV e JSON de outros gerenciadores, com leitores próprios do LordOS. **Exportação** para uma cópia criptografada, ou para CSV depois de um aviso em vermelho.
+
+[[shot:3]]
+
+## Como você desbloqueia
+
+O cofre tem uma chave aleatória de 32 bytes. Ela nunca é derivada da sua senha. Em vez disso, cada forma de desbloqueio embrulha essa mesma chave:
+
+- **uma senha mestra**, reforçada com Argon2id, com o custo medido na sua máquina para levar cerca de 0,7 s;
+- **uma chave de segurança FIDO2** com a extensão `hmac-secret`, pelo cliente CTAP2 próprio do LordOS;
+- **um arquivo-chave**, por exemplo num pendrive;
+- **uma senha mais um arquivo-chave**, como dois fatores;
+- **uma chave de recuperação imprimível** de 40 caracteres.
+
+Vários métodos podem conviver. Por padrão, o cofre se tranca sozinho depois de 5 minutos sem uso, quando você bloqueia a tela e quando troca de usuário.
+
+[[shot:1]]
+
+## Como ele protege seus segredos
+
+**O arquivo.** Um único arquivo `.lvault`, criptografado com XChaCha20-Poly1305. O cabeçalho é autenticado junto com o corpo, então alterar qualquer byte, trocar um método de desbloqueio ou truncar o arquivo é detectado. A suíte de testes inverte cada byte de um cofre e confere se cada alteração é pega: 1.165 de 1.165. O salvamento é atômico, com um `.bak` da versão anterior.
+
+**O processo.** O `lord-vault` é iniciado pelo `lord-server` a partir de um caminho fixo e sem argumentos, e se tranca antes de ler qualquer coisa: sem rede, sem sockets novos, sem executar programas, sem arquivos além da pasta do cofre que ele recebe já aberta. Ele não pode ser depurado nem ter a memória despejada por outros processos do seu usuário, e os segredos ficam em memória travada (`mlock`), excluída dos core dumps e apagada ao ser liberada.
+
+**A janela.** A própria janela de Senhas roda como um processo em sandbox próprio (`lord-server --app passwords`), fora do JavaScript do desktop. Os valores revelados nunca entram na memória do desktop. As listas mostram títulos e nomes de usuário, nunca segredos; um valor só trafega quando você clica em revelar, copiar ou editar.
+
+**A tela.** A janela de Senhas é protegida: sai preta em capturas de tela, gravações de tela e na área de trabalho remota.
+
+**A área de transferência.** Um segredo copiado fica fora do histórico da área de transferência, é marcado como sensível para os apps Linux que respeitam essa convenção e é apagado depois de 30 segundos (configurável), se ainda estiver lá.
+
+[[shot:2]]
+
+## O chaveiro do sistema
+
+- **Aberto no login.** O `lord-sessiond` confere sua senha de login, entrega-a uma única vez ao `lord-vault` para abrir o chaveiro da sessão e apaga a própria cópia.
+- **Os apps do LordOS** guardam seus segredos com o `keyring` do SDK. Cada app vê só os próprios itens. Para os apps `.lpk` instalados, o `lord-server` define o dono a partir da identidade verificada do app, então um app não consegue se passar por outro. Se um app pede um item de outro app, o sistema pergunta a você antes.
+- **Os apps Linux** usam o Secret Service padrão do freedesktop sobre D-Bus, servido por código próprio do LordOS. O Chromium foi testado de ponta a ponta: salvou um login, reiniciou, buscou a chave dele no chaveiro do LordOS e preencheu o login.
+
+[[shot:4]]
+
+## As perguntas do leitor cético
+
+**Quem pode ler o chaveiro da sessão?** Dentro do LordOS, cada app só os próprios itens, a menos que você compartilhe algum. Pelo Secret Service, a regra de acesso é a do freedesktop: qualquer app Linux da sua sessão que alcance o barramento da sessão pode ler a coleção desbloqueada, como acontece com outros chaveiros de desktop. Os apps `.lpk` isolados não alcançam o barramento.
+
+**O app Senhas pode ler a chave de segurança diretamente?** Não. Usar uma chave de segurança passa pelo aviso da permissão `usb`; depois o `lord-server` abre o dispositivo e o entrega direto ao `lord-vault`. Nem a janela do app nem o JavaScript dela chegam a segurá-lo.
+
+## Limites honestos
+
+- **Chaves de segurança reais não foram testadas.** O caminho FIDO2 foi testado só contra um autenticador em software. Chaves que verificam apenas com leitor de digital embutido, e o protocolo de PIN 2, mais novo, não são suportados.
+- **O Secret Service é mínimo:** uma coleção, sem regras de acesso por app, sem avisos de exclusão.
+- **A grande área de trabalho do Argon2 não pode ser travada na memória** com o limite padrão do Debian; ela é excluída dos dumps e apagada após cada uso.
+- **Algumas variantes de KDBX não são suportadas** (Twofish e Argon2 versão 0x10).
+
+## Leia o código
+
+- [server/src/vault/vault.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/vault.c): o processo `lord-vault` e seu sandbox
+- [server/src/vault/vfile.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/vfile.c): o formato `.lvault` e os métodos de desbloqueio
+- [server/src/vault/smem.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/smem.c): a área de memória travada e apagada
+- [server/src/vault/keyring.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/keyring.c) e [server/src/vault/secretsvc.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/secretsvc.c): o chaveiro e o Secret Service
+- [server/src/vault/ctap2.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/ctap2.c): o cliente FIDO2
+- [server/src/sec/brokerkr.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/brokerkr.c): o chaveiro para apps isolados
+- [apps/passwords](https://github.com/lordbasex/LordOS/tree/main/apps/passwords): o app
+- [docs/PASSWORDS.md](https://github.com/lordbasex/LordOS/blob/main/docs/PASSWORDS.md)
diff --git a/web/content/features/private-by-design.en.md b/web/content/features/private-by-design.en.md
new file mode 100644
index 0000000..3e2fb4a
--- /dev/null
+++ b/web/content/features/private-by-design.en.md
@@ -0,0 +1,109 @@
+## The short version
+
+An installable LordOS app (a `.lpk` package) doesn't get the keys to your house. It runs in a room of its own, with the door locked from the outside. When it needs something, it asks the system through a single hatch, the **broker**. The system checks what you decided, and if you haven't decided yet, it asks you with a prompt that the system draws, not the app.
+
+[[shot:0]]
+
+Three ideas do most of the work:
+
+- **Isolation.** Each `.lpk` app is its own process, locked in with Linux kernel features before any of its code runs.
+- **Mediation.** Everything that touches your things (files, camera, microphone, clipboard, passwords) goes through the broker in `lord-server`, which checks the permission on every request.
+- **Your decision, stored where the app can't reach it.** Decisions live in `~/.config/lordos/permisos.json`, which isolated apps cannot see or write.
+
+[[diagram:permission]]
+
+## Which apps are isolated, exactly?
+
+This is the first question a careful reader should ask, so here is the precise answer:
+
+| Kind of app | Own process | Sandbox (Landlock + seccomp) | Per-app cgroup | Broker and permissions | Per-app firewall |
+|---|---|---|---|---|---|
+| Installed `.lpk` apps | yes | yes | yes, with memory and CPU limits | yes | yes |
+| Passwords (the only built-in app in its own process today) | yes | yes | yes | yes | yes |
+| Other built-in apps (Files, Settings, Mail, Terminal…) | no, they run inside `lord-server` | no | no (they count as "LordOS") | their camera, microphone and screen use is checked in C | yes, as "LordOS" |
+| Linux apps opened from the app launcher (apt, the Store) | yes, a normal process | **no** | yes, `app-lordos-<id>.scope`, no limits | **no** | **yes** |
+| Programs started from the Terminal | yes | no | they share the Terminal's place in the tree | no | as "LordOS" |
+
+So: **Linux apps are not sandboxed by LordOS.** They run as your user, exactly as on any Debian system, and can read your home folder. What LordOS adds for them is attribution (the Monitor knows which app made each connection) and the kernel-enforced per-app firewall. Flatpak is not used or integrated by LordOS, and it hasn't been tested.
+
+Built-in apps are part of the system's own code, reviewed with it; they don't get the per-process isolation that third-party packages get, with Passwords as the exception because it holds your secrets.
+
+## How the sandbox works
+
+The sandbox is LordOS's own code (`server/src/sec/sandbox.c`), not bubblewrap, Flatpak or firejail. It uses kernel features directly, and it is applied **after** the app connects to the compositor and to the broker, and **before** any line of the app's code is loaded.
+
+[[diagram:sandbox]]
+
+- **Landlock** limits the files the process can touch: read-only access to its own package, the shared app runtime, fonts and libraries; read and write access only to `~/.local/share/lordos/appdata/<id>`. Nothing else from your home folder, and no `/dev`.
+- **seccomp-bpf** is an allow list of system calls, applied to every thread. Calls like `ptrace`, `mount`, `bpf`, `execve`, `keyctl` and module loading are simply not on it. The app can't open new Unix sockets either, so it can't reach the session bus, the printing service or the Wayland socket on its own.
+- **No privileges.** `no_new_privs` is set and every capability is dropped.
+- **A cgroup of its own**, `app-lordos-lpk-<id>.scope`, with a soft memory limit of 192 MB, a hard one of 512 MB and at most one CPU core. The scope is created and owned by root (`lord-sessiond`), so the app can't move itself elsewhere.
+- **Network only with permission.** Without the `network` permission, seccomp refuses to create internet sockets and Landlock refuses TCP connect and bind. With it (declared in the manifest **and** allowed by you), they are allowed, and the per-app firewall still applies.
+
+**Are namespaces used?** No. `lord-server` runs without root, and creating a network namespace needs privileges it doesn't have. The design uses Landlock, seccomp and cgroups instead, and leaves the app in the machine's network namespace under the rules above.
+
+The project keeps a deliberately malicious test app (`tests/lpk-evil`). It declares no permissions and tries everything at start: reading `~/.ssh/id_rsa` and `settings.json`, writing outside its folder, reading the clipboard silently, opening `/etc/shadow`, opening a socket, running `/bin/sh`, `ptrace`, opening the graphics card. Every attempt is blocked. The sandbox test suite passes 14 of 14 checks for apps, 14 of 14 with network and 17 of 17 for helpers.
+
+[[shot:1]]
+
+## What you see and decide
+
+- **The prompt.** The first time an app asks for something, the system shows: *"App" wants to use the microphone — Allow / Don't Allow*. The answer is saved for that app.
+- **Settings → Privacy** lists each permission with the apps that asked for it and an Allow / Ask / Deny control.
+- **Indicators.** A green dot in the menu bar while the camera is in use, an orange one for the microphone. Tapping it shows which app.
+
+Permissions an app can declare: files, clipboard, notifications, network, camera, microphone, screen, listen, USB, Bluetooth and apps. An app can't get a permission it didn't declare.
+
+[[shot:4]]
+
+## The skeptical reader's questions
+
+**Can the prompt be bypassed?** Not by the isolated app. The prompt is drawn by the session, outside the app's window. The answer reaches `lord-server` directly, and the broker reads the stored decision in C on every request. The decisions file is outside what Landlock lets the app see, and `lord.fs` refuses to write it. An app could draw a fake dialog inside its own window, but clicking it changes nothing. The honest gap: a Linux app, which isn't sandboxed and runs as you, could edit `permisos.json` like any other file in your home.
+
+**Do I get "Allow once" or "Allow always"?** Today the prompt offers Allow and Don't Allow, and the decision is remembered until you change it in Settings. There is no "allow once" for app permissions yet.
+
+**Does an app get only the file I choose?** Yes. To open or save, an isolated app calls the system file dialog. `lord-server` draws it (the "powerbox"), opens the file you picked with your permissions and passes the app **only that file descriptor**. The app never sees the folder or the rest of the disk. No extra permission is needed, because picking the file is the consent.
+
+[[shot:2]]
+
+**How are the camera and the microphone mediated?** The app never opens the device.
+- *Microphone:* `lord-server` opens the PipeWire capture stream and writes the audio into a shared ring; the app gets a **read-only** copy of it.
+- *Camera:* `lord-server` opens `/dev/videoN` and hands it only to the sandboxed media helper, `lord-media`, which decodes frames into a sealed shared ring. The app gets a read-only mapping and must acknowledge each frame; `lord-server` validates every acknowledgement (generation, slot, rate). Photos and videos go to a file you choose in the system's save dialog.
+
+[[diagram:camera]]
+
+**Can permissions be revoked while the app runs?** Yes, for the camera and the microphone: setting either to Ask or Deny in Settings stops it at once. For the camera, `lord-server` kills the app's `lord-media` process (tested: gone within 0.5 s); for the microphone, it closes the PipeWire stream. Checks like the clipboard apply on the next request. The `network` permission is decided when the app starts, so a change applies at the next launch; to cut a running app off the network immediately, use the firewall switch in the Monitor.
+
+[[shot:3]]
+
+**What about apps that need more privileges?** There is no way for a `.lpk` app to get root or extra capabilities. Everything in LordOS that needs root goes through a closed list of validated actions (`server/src/admin.c`), and JavaScript can't run arbitrary commands. Linux apps behave as on any Debian system: if a program needs `sudo`, you run it yourself in the Terminal.
+
+## The helpers that read untrusted data
+
+Files from outside are the classic way in. LordOS opens them in small separate processes that are locked in even harder than apps: `lord-doc` (PDFs, archives, fonts), `lord-media` (video, music, photos, camera), `lord-maild` (mail, calendars, contacts) and `lord-vault` (passwords). They have no network, can't create sockets, can't run programs and can only create threads, not processes. They don't open paths: `lord-server` opens files and passes them as file descriptors. If seccomp can't be applied, the helper exits rather than run unconfined. A malicious PDF can crash `lord-doc`, but not the desktop.
+
+## Protected windows
+
+A window can be marked protected. Passwords is. Its pixels come out black in LordOS screenshots, screen recordings, thumbnails and the remote desktop, while the real monitor shows it normally. Linux apps can't capture the screen through LordOS: the compositor doesn't offer any screen-capture protocol to them.
+
+[[shot:5]]
+
+## Honest limits
+
+- **Linux apps are not sandboxed.** Only network rules and attribution apply to them.
+- **Camera and microphone use by Linux apps is not shown** in the indicators yet. The Monitor's device list is planned.
+- **Some firewall "restrictions" are not enforced yet.** Settings lets you tick "no camera", "no microphone", "no screen", "no USB", "no Bluetooth", "no files" and "no notifications" for an app. They are stored, but no component checks them today; only the four network restrictions are enforced. For camera and microphone, use the permission itself (Deny), which is enforced.
+- **The broker doesn't cover everything yet.** Permissions like Bluetooth or launching other apps can be declared, but there is no broker call for them, so an isolated app simply can't do those things.
+- **A missing kernel feature weakens the app sandbox quietly.** If Landlock or a cgroup controller is missing, apps still start, with a warning in the log. Helpers, by contrast, refuse to run without seccomp.
+
+## Read the source
+
+- [server/src/sec/sandbox.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/sandbox.c): Landlock, seccomp, capabilities, network rules
+- [server/src/sec/brokersrv.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/brokersrv.c): the broker, server side
+- [server/src/sec/perms.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/perms.c): per-app permissions
+- [server/src/sec/brokercam.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/brokercam.c): the camera for isolated apps
+- [server/src/sec/cgroup.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/cgroup.c) and [server/src/remote/cgsup.c](https://github.com/lordbasex/LordOS/blob/main/server/src/remote/cgsup.c): root-owned app scopes
+- [server/src/app/appclient.c](https://github.com/lordbasex/LordOS/blob/main/server/src/app/appclient.c): the isolated app process
+- [sdk/privacy.js](https://github.com/lordbasex/LordOS/blob/main/sdk/privacy.js) and [sdk/powerbox.jsx](https://github.com/lordbasex/LordOS/blob/main/sdk/powerbox.jsx): prompts and the file dialog
+- [server/tests/sandbox_test.c](https://github.com/lordbasex/LordOS/blob/main/server/tests/sandbox_test.c) and [tests/lpk-evil](https://github.com/lordbasex/LordOS/tree/main/tests/lpk-evil): the tests
+- [docs/PRIVACY.md](https://github.com/lordbasex/LordOS/blob/main/docs/PRIVACY.md)
diff --git a/web/content/features/private-by-design.es.md b/web/content/features/private-by-design.es.md
new file mode 100644
index 0000000..3a0c80d
--- /dev/null
+++ b/web/content/features/private-by-design.es.md
@@ -0,0 +1,109 @@
+## En pocas palabras
+
+Una app instalable de LordOS (un paquete `.lpk`) no recibe las llaves de tu casa. Corre en una habitación propia, con la puerta cerrada desde afuera. Cuando necesita algo, se lo pide al sistema por una sola ventanilla, el **broker**. El sistema revisa lo que decidiste, y si todavía no decidiste, te pregunta con un aviso que dibuja el sistema, no la app.
+
+[[shot:0]]
+
+Tres ideas hacen casi todo el trabajo:
+
+- **Aislamiento.** Cada app `.lpk` es su propio proceso, encerrado con funciones del kernel Linux antes de que corra una sola línea de su código.
+- **Mediación.** Todo lo que toca tus cosas (archivos, cámara, micrófono, portapapeles, contraseñas) pasa por el broker en `lord-server`, que revisa el permiso en cada pedido.
+- **Tu decisión, guardada donde la app no llega.** Las decisiones viven en `~/.config/lordos/permisos.json`, que las apps aisladas no pueden ver ni escribir.
+
+[[diagram:permission]]
+
+## ¿Qué apps están aisladas, exactamente?
+
+Es la primera pregunta que tiene que hacerse un lector cuidadoso, así que acá va la respuesta precisa:
+
+| Tipo de app | Proceso propio | Caja de arena (Landlock + seccomp) | cgroup por app | Broker y permisos | Firewall por app |
+|---|---|---|---|---|---|
+| Apps `.lpk` instaladas | sí | sí | sí, con límites de memoria y CPU | sí | sí |
+| Contraseñas (hoy la única app incluida con proceso propio) | sí | sí | sí | sí | sí |
+| Otras apps incluidas (Archivos, Ajustes, Mail, Terminal…) | no, corren dentro de `lord-server` | no | no (cuentan como "LordOS") | su uso de cámara, micrófono y pantalla se revisa en C | sí, como "LordOS" |
+| Apps de Linux abiertas desde el lanzador de apps (apt, la Tienda) | sí, un proceso común | **no** | sí, `app-lordos-<id>.scope`, sin límites | **no** | **sí** |
+| Programas iniciados desde la Terminal | sí | no | comparten el lugar de la Terminal en el árbol | no | como "LordOS" |
+
+O sea: **LordOS no encierra a las apps de Linux en una caja de arena.** Corren como tu usuario, exactamente como en cualquier sistema Debian, y pueden leer tu carpeta personal. Lo que LordOS les suma es atribución (el Monitor sabe qué app hizo cada conexión) y el firewall por app que aplica el kernel. LordOS no usa ni integra Flatpak, y no se probó.
+
+Las apps incluidas son parte del código propio del sistema y se revisan junto con él; no tienen el aislamiento por proceso que tienen los paquetes de terceros, con la excepción de Contraseñas, porque guarda tus secretos.
+
+## Cómo funciona la caja de arena
+
+La caja de arena es código propio de LordOS (`server/src/sec/sandbox.c`), no bubblewrap, Flatpak ni firejail. Usa directamente funciones del kernel, y se aplica **después** de que la app se conecta al compositor y al broker, y **antes** de cargar cualquier línea de código de la app.
+
+[[diagram:sandbox]]
+
+- **Landlock** limita los archivos que el proceso puede tocar: lectura sola de su propio paquete, del entorno compartido de las apps, de las fuentes y las bibliotecas; lectura y escritura solo en `~/.local/share/lordos/appdata/<id>`. Nada más de tu carpeta personal, y nada de `/dev`.
+- **seccomp-bpf** es una lista de llamadas al sistema permitidas, aplicada a cada hilo. Llamadas como `ptrace`, `mount`, `bpf`, `execve`, `keyctl` y la carga de módulos directamente no están. La app tampoco puede abrir sockets Unix nuevos, así que no puede llegar por su cuenta al bus de la sesión, al servicio de impresión ni al socket Wayland.
+- **Sin privilegios.** Se activa `no_new_privs` y se quitan todas las capacidades.
+- **Un cgroup propio**, `app-lordos-lpk-<id>.scope`, con un límite blando de memoria de 192 MB, uno duro de 512 MB y como máximo un núcleo de CPU. El scope lo crea y lo tiene root (`lord-sessiond`), así que la app no se puede mudar a otro lado.
+- **Red solo con permiso.** Sin el permiso `network`, seccomp se niega a crear sockets de internet y Landlock niega el connect y el bind de TCP. Con el permiso (declarado en el manifiesto **y** permitido por vos), se habilitan, y el firewall por app sigue aplicando.
+
+**¿Se usan namespaces?** No. `lord-server` corre sin root, y crear un namespace de red necesita privilegios que no tiene. El diseño usa Landlock, seccomp y cgroups en su lugar, y deja la app en el namespace de red de la máquina bajo las reglas de arriba.
+
+El proyecto mantiene una app de prueba maliciosa a propósito (`tests/lpk-evil`). No declara permisos e intenta de todo al arrancar: leer `~/.ssh/id_rsa` y `settings.json`, escribir fuera de su carpeta, leer el portapapeles sin avisar, abrir `/etc/shadow`, abrir un socket, ejecutar `/bin/sh`, `ptrace`, abrir la placa de video. Todos los intentos quedan bloqueados. La batería de pruebas de la caja de arena pasa 14 de 14 controles para apps, 14 de 14 con red y 17 de 17 para ayudantes.
+
+[[shot:1]]
+
+## Qué ves y qué decidís
+
+- **El aviso.** La primera vez que una app pide algo, el sistema muestra: *«App» quiere usar el micrófono — Permitir / No permitir*. La respuesta queda guardada para esa app.
+- **Ajustes → Privacidad** lista cada permiso con las apps que lo pidieron y un control Permitir / Preguntar / Denegar.
+- **Indicadores.** Un punto verde en la barra de menú mientras se usa la cámara, uno naranja para el micrófono. Si lo tocás, te muestra qué app es.
+
+Permisos que una app puede declarar: archivos, portapapeles, notificaciones, red, cámara, micrófono, pantalla, escuchar conexiones, USB, Bluetooth y apps. Una app no puede obtener un permiso que no declaró.
+
+[[shot:4]]
+
+## Las preguntas del lector escéptico
+
+**¿Se puede saltear el aviso?** La app aislada no. El aviso lo dibuja la sesión, fuera de la ventana de la app. La respuesta llega directo a `lord-server`, y el broker lee en C la decisión guardada en cada pedido. El archivo de decisiones está fuera de lo que Landlock le deja ver a la app, y `lord.fs` se niega a escribirlo. Una app podría dibujar un diálogo falso dentro de su propia ventana, pero tocarlo no cambia nada. El hueco honesto: una app de Linux, que no está en caja de arena y corre como vos, podría editar `permisos.json` como cualquier otro archivo de tu carpeta personal.
+
+**¿Tengo "Permitir una vez" o "Permitir siempre"?** Hoy el aviso ofrece Permitir y No permitir, y la decisión se recuerda hasta que la cambies en Ajustes. Todavía no hay "permitir una vez" para los permisos de las apps.
+
+**¿La app recibe solo el archivo que elijo?** Sí. Para abrir o guardar, una app aislada llama al diálogo de archivos del sistema. `lord-server` lo dibuja (el "powerbox"), abre con tus permisos el archivo que elegiste y le pasa a la app **solo ese descriptor de archivo**. La app nunca ve la carpeta ni el resto del disco. No hace falta un permiso extra, porque elegir el archivo ya es el consentimiento.
+
+[[shot:2]]
+
+**¿Cómo se median la cámara y el micrófono?** La app nunca abre el dispositivo.
+- *Micrófono:* `lord-server` abre el flujo de captura de PipeWire y escribe el audio en un anillo compartido; la app recibe una copia **de solo lectura**.
+- *Cámara:* `lord-server` abre `/dev/videoN` y se lo pasa solo al ayudante multimedia aislado, `lord-media`, que decodifica los cuadros a un anillo compartido sellado. La app recibe un mapeo de solo lectura y tiene que confirmar cada cuadro; `lord-server` valida cada confirmación (generación, posición, ritmo). Las fotos y los videos van a un archivo que elegís en el diálogo de guardar del sistema.
+
+[[diagram:camera]]
+
+**¿Se pueden revocar permisos mientras la app corre?** Sí, para la cámara y el micrófono: pasar cualquiera de los dos a Preguntar o Denegar en Ajustes lo corta al instante. Para la cámara, `lord-server` mata el proceso `lord-media` de la app (probado: desaparece en menos de 0,5 s); para el micrófono, cierra el flujo de PipeWire. Controles como el del portapapeles se aplican en el próximo pedido. El permiso `network` se decide cuando arranca la app, así que un cambio vale desde el próximo inicio; para cortarle la red al instante a una app que está corriendo, usá el interruptor del firewall en el Monitor.
+
+[[shot:3]]
+
+**¿Y las apps que necesitan más privilegios?** No hay forma de que una app `.lpk` obtenga root ni capacidades extra. Todo lo que en LordOS necesita root pasa por una lista cerrada de acciones validadas (`server/src/admin.c`), y JavaScript no puede ejecutar comandos arbitrarios. Las apps de Linux se comportan como en cualquier sistema Debian: si un programa necesita `sudo`, lo corrés vos en la Terminal.
+
+## Los ayudantes que leen datos no confiables
+
+Los archivos que vienen de afuera son la puerta de entrada clásica. LordOS los abre en procesos chicos y separados que están todavía más encerrados que las apps: `lord-doc` (PDF, archivos comprimidos, fuentes), `lord-media` (video, música, fotos, cámara), `lord-maild` (correo, calendarios, contactos) y `lord-vault` (contraseñas). No tienen red, no pueden crear sockets, no pueden ejecutar programas y solo pueden crear hilos, no procesos. No abren rutas: `lord-server` abre los archivos y se los pasa como descriptores. Si seccomp no se puede aplicar, el ayudante termina en lugar de correr sin encierro. Un PDF malicioso puede tumbar a `lord-doc`, pero no al escritorio.
+
+## Ventanas protegidas
+
+Una ventana se puede marcar como protegida. La de Contraseñas lo está. Sus píxeles salen en negro en las capturas de LordOS, las grabaciones de pantalla, las miniaturas y el escritorio remoto, mientras el monitor real la muestra normal. Las apps de Linux no pueden capturar la pantalla a través de LordOS: el compositor no les ofrece ningún protocolo de captura.
+
+[[shot:5]]
+
+## Límites honestos
+
+- **Las apps de Linux no están en caja de arena.** A ellas solo se les aplican las reglas de red y la atribución.
+- **El uso de cámara y micrófono por apps de Linux todavía no se muestra** en los indicadores. La lista de dispositivos del Monitor está planeada.
+- **Algunas "restricciones" del firewall todavía no se aplican.** Ajustes te deja marcar "sin cámara", "sin micrófono", "sin captura de pantalla", "sin USB", "sin Bluetooth", "sin archivos fuera del selector" y "sin notificaciones" para una app. Se guardan, pero hoy ningún componente las revisa; solo se aplican las cuatro restricciones de red. Para la cámara y el micrófono, usá el permiso en sí (Denegar), que sí se aplica.
+- **El broker todavía no cubre todo.** Permisos como Bluetooth o abrir otras apps se pueden declarar, pero no hay una llamada del broker para ellos, así que una app aislada directamente no puede hacer esas cosas.
+- **Si falta una función del kernel, la caja de arena de las apps se debilita sin hacer ruido.** Si faltan Landlock o un controlador de cgroup, las apps igual arrancan, con una advertencia en el registro. Los ayudantes, en cambio, se niegan a correr sin seccomp.
+
+## Leé el código
+
+- [server/src/sec/sandbox.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/sandbox.c): Landlock, seccomp, capacidades, reglas de red
+- [server/src/sec/brokersrv.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/brokersrv.c): el broker, del lado del servidor
+- [server/src/sec/perms.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/perms.c): permisos por app
+- [server/src/sec/brokercam.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/brokercam.c): la cámara para apps aisladas
+- [server/src/sec/cgroup.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/cgroup.c) y [server/src/remote/cgsup.c](https://github.com/lordbasex/LordOS/blob/main/server/src/remote/cgsup.c): scopes de las apps en manos de root
+- [server/src/app/appclient.c](https://github.com/lordbasex/LordOS/blob/main/server/src/app/appclient.c): el proceso de la app aislada
+- [sdk/privacy.js](https://github.com/lordbasex/LordOS/blob/main/sdk/privacy.js) y [sdk/powerbox.jsx](https://github.com/lordbasex/LordOS/blob/main/sdk/powerbox.jsx): los avisos y el diálogo de archivos
+- [server/tests/sandbox_test.c](https://github.com/lordbasex/LordOS/blob/main/server/tests/sandbox_test.c) y [tests/lpk-evil](https://github.com/lordbasex/LordOS/tree/main/tests/lpk-evil): las pruebas
+- [docs/PRIVACY.md](https://github.com/lordbasex/LordOS/blob/main/docs/PRIVACY.md)
diff --git a/web/content/features/private-by-design.meta.json b/web/content/features/private-by-design.meta.json
new file mode 100644
index 0000000..821990a
--- /dev/null
+++ b/web/content/features/private-by-design.meta.json
@@ -0,0 +1,483 @@
+{
+ "slug": "private-by-design",
+ "order": 2,
+ "title": {
+ "en": "Private by design",
+ "es": "Privado por diseño",
+ "pt": "Privado por padrão"
+ },
+ "tagline": {
+ "en": "Installable apps run locked in their own process and ask before touching your camera, microphone or files.",
+ "es": "Las apps instalables corren encerradas en su propio proceso y piden permiso antes de tocar tu cámara, micrófono o archivos.",
+ "pt": "Apps instaláveis rodam trancados no próprio processo e pedem permissão antes de tocar na câmera, no microfone ou nos arquivos."
+ },
+ "lumo": {
+ "pose": "front",
+ "intro": {
+ "en": "I'm the one standing at the door. Apps you install get a room of their own, and when they want your camera, your microphone or a file, they have to ask me first, and I ask you.",
+ "es": "Yo soy el que está en la puerta. Las apps que instalás tienen su propio cuarto, y cuando quieren tu cámara, tu micrófono o un archivo, primero me lo tienen que pedir a mí, y yo te pregunto a vos.",
+ "pt": "Eu sou quem fica na porta. Os apps que você instala ganham um quarto só deles, e quando querem sua câmera, seu microfone ou um arquivo, primeiro precisam pedir para mim, e eu pergunto para você."
+ }
+ },
+ "screenshots": [
+ {
+ "file": "docs/privacy-prompt-broker.png",
+ "caption": {
+ "en": "An isolated test app asks for the microphone; the system draws the prompt.",
+ "es": "Una app de prueba aislada pide el micrófono; el aviso lo dibuja el sistema.",
+ "pt": "Um app de teste isolado pede o microfone; o aviso é desenhado pelo sistema."
+ }
+ },
+ {
+ "file": "docs/privacy-rogue-process.png",
+ "caption": {
+ "en": "The deliberately malicious test app in its own process: every attempt blocked.",
+ "es": "La app de prueba maliciosa a propósito, en su propio proceso: todos los intentos bloqueados.",
+ "pt": "O app de teste propositalmente malicioso, no próprio processo: todas as tentativas bloqueadas."
+ }
+ },
+ {
+ "file": "docs/privacy-file-picker.png",
+ "caption": {
+ "en": "The system file dialog: lord-server draws it and the app receives only the chosen file.",
+ "es": "El diálogo de archivos del sistema: lo dibuja lord-server y la app recibe solo el archivo elegido.",
+ "pt": "O diálogo de arquivos do sistema: o lord-server o desenha e o app recebe só o arquivo escolhido."
+ }
+ },
+ {
+ "file": "docs/isolation-camera-revoked.png",
+ "caption": {
+ "en": "After Deny in Settings, the camera stream stopped and the green dot went away.",
+ "es": "Después de Denegar en Ajustes, la cámara se cortó y el punto verde desapareció.",
+ "pt": "Depois de Negar em Ajustes, a câmera parou e o ponto verde sumiu."
+ }
+ },
+ {
+ "file": "docs/privacy-settings.png",
+ "caption": {
+ "en": "Settings → Privacy: each permission with its apps and an Allow / Ask / Deny control.",
+ "es": "Ajustes → Privacidad: cada permiso con sus apps y un control Permitir / Preguntar / Denegar.",
+ "pt": "Ajustes → Privacidade: cada permissão com seus apps e um controle Permitir / Perguntar / Negar."
+ }
+ },
+ {
+ "file": "docs/protected-window-capture.png",
+ "caption": {
+ "en": "A protected window comes out black in a LordOS screenshot.",
+ "es": "Una ventana protegida sale en negro en una captura de LordOS.",
+ "pt": "Uma janela protegida sai preta numa captura do LordOS."
+ }
+ }
+ ],
+ "diagrams": [
+ {
+ "id": "permission",
+ "kind": "flow",
+ "title": {
+ "en": "How a permission request travels",
+ "es": "Cómo viaja un pedido de permiso",
+ "pt": "Como um pedido de permissão viaja"
+ },
+ "nodes": [
+ {
+ "id": "app",
+ "label": {
+ "en": "Isolated app",
+ "es": "App aislada",
+ "pt": "App isolado"
+ },
+ "sub": {
+ "en": "Asks through the broker socket",
+ "es": "Pide por el socket del broker",
+ "pt": "Pede pelo socket do broker"
+ },
+ "tone": "user"
+ },
+ {
+ "id": "broker",
+ "label": {
+ "en": "Broker in lord-server",
+ "es": "Broker en lord-server",
+ "pt": "Broker no lord-server"
+ },
+ "sub": {
+ "en": "Looks up the stored decision (perms.c)",
+ "es": "Busca la decisión guardada (perms.c)",
+ "pt": "Consulta a decisão salva (perms.c)"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "prompt",
+ "label": {
+ "en": "System prompt",
+ "es": "Aviso del sistema",
+ "pt": "Aviso do sistema"
+ },
+ "sub": {
+ "en": "Only if not decided yet; drawn by the session",
+ "es": "Solo si todavía no se decidió; lo dibuja la sesión",
+ "pt": "Só se ainda não foi decidido; desenhado pela sessão"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "user",
+ "label": {
+ "en": "You decide",
+ "es": "Vos decidís",
+ "pt": "Você decide"
+ },
+ "sub": {
+ "en": "Allow or Don't Allow, saved in permisos.json",
+ "es": "Permitir o No permitir, guardado en permisos.json",
+ "pt": "Permitir ou Não permitir, salvo em permisos.json"
+ },
+ "tone": "user"
+ },
+ {
+ "id": "enforce",
+ "label": {
+ "en": "Enforced",
+ "es": "Se aplica",
+ "pt": "Aplicado"
+ },
+ "sub": {
+ "en": "Broker checks every call; sandbox and kernel block the rest",
+ "es": "El broker revisa cada llamada; la caja de arena y el kernel bloquean el resto",
+ "pt": "O broker confere cada chamada; o sandbox e o kernel bloqueiam o resto"
+ },
+ "tone": "kernel"
+ },
+ {
+ "id": "revoke",
+ "label": {
+ "en": "Revocable",
+ "es": "Revocable",
+ "pt": "Revogável"
+ },
+ "sub": {
+ "en": "Settings → Privacy; camera and microphone stop at once",
+ "es": "Ajustes → Privacidad; cámara y micrófono se cortan al instante",
+ "pt": "Ajustes → Privacidade; câmera e microfone param na hora"
+ },
+ "tone": "allow"
+ }
+ ],
+ "edges": [
+ {
+ "from": "app",
+ "to": "broker",
+ "label": {
+ "en": "request",
+ "es": "pedido",
+ "pt": "pedido"
+ }
+ },
+ {
+ "from": "broker",
+ "to": "prompt",
+ "label": {
+ "en": "state is Ask",
+ "es": "estado Preguntar",
+ "pt": "estado Perguntar"
+ }
+ },
+ {
+ "from": "prompt",
+ "to": "user",
+ "label": {
+ "en": "shown",
+ "es": "se muestra",
+ "pt": "exibido"
+ }
+ },
+ {
+ "from": "user",
+ "to": "enforce",
+ "label": {
+ "en": "answer",
+ "es": "respuesta",
+ "pt": "resposta"
+ }
+ },
+ {
+ "from": "enforce",
+ "to": "revoke",
+ "label": {
+ "en": "later",
+ "es": "después",
+ "pt": "depois"
+ }
+ }
+ ],
+ "caption": {
+ "en": "The app never answers its own prompt: the decision is stored where it can't write, and checked in C on every request.",
+ "es": "La app nunca responde su propio aviso: la decisión se guarda donde no puede escribir y se revisa en C en cada pedido.",
+ "pt": "O app nunca responde ao próprio aviso: a decisão fica onde ele não pode escrever e é conferida em C a cada pedido."
+ }
+ },
+ {
+ "id": "sandbox",
+ "kind": "stack",
+ "title": {
+ "en": "The walls around an installed app",
+ "es": "Las paredes alrededor de una app instalada",
+ "pt": "As paredes em volta de um app instalado"
+ },
+ "nodes": [
+ {
+ "id": "code",
+ "label": {
+ "en": "The app's code",
+ "es": "El código de la app",
+ "pt": "O código do app"
+ },
+ "sub": {
+ "en": "Loaded only after the walls are up",
+ "es": "Se carga recién cuando las paredes están puestas",
+ "pt": "Carregado só depois que as paredes estão de pé"
+ },
+ "tone": "user"
+ },
+ {
+ "id": "landlock",
+ "label": {
+ "en": "Landlock",
+ "es": "Landlock",
+ "pt": "Landlock"
+ },
+ "sub": {
+ "en": "Files: its package read-only, its own data folder read-write, nothing else of your home",
+ "es": "Archivos: su paquete de solo lectura, su carpeta de datos de lectura y escritura, nada más de tu carpeta personal",
+ "pt": "Arquivos: o pacote só leitura, a pasta de dados leitura e escrita, nada mais da sua pasta pessoal"
+ },
+ "tone": "kernel"
+ },
+ {
+ "id": "seccomp",
+ "label": {
+ "en": "seccomp-bpf",
+ "es": "seccomp-bpf",
+ "pt": "seccomp-bpf"
+ },
+ "sub": {
+ "en": "An allow list of system calls; no exec, ptrace, mount or new sockets",
+ "es": "Una lista de llamadas al sistema permitidas; sin exec, ptrace, mount ni sockets nuevos",
+ "pt": "Uma lista de chamadas de sistema permitidas; sem exec, ptrace, mount nem sockets novos"
+ },
+ "tone": "kernel"
+ },
+ {
+ "id": "caps",
+ "label": {
+ "en": "No privileges",
+ "es": "Sin privilegios",
+ "pt": "Sem privilégios"
+ },
+ "sub": {
+ "en": "no_new_privs, every capability dropped",
+ "es": "no_new_privs, todas las capacidades quitadas",
+ "pt": "no_new_privs, todas as capacidades removidas"
+ },
+ "tone": "kernel"
+ },
+ {
+ "id": "cgroup",
+ "label": {
+ "en": "cgroup v2 scope",
+ "es": "Scope de cgroup v2",
+ "pt": "Escopo de cgroup v2"
+ },
+ "sub": {
+ "en": "Root-owned; 512 MB and one core at most; the firewall knows the app by it",
+ "es": "De root; 512 MB y un núcleo como máximo; el firewall reconoce la app por él",
+ "pt": "Do root; no máximo 512 MB e um núcleo; o firewall reconhece o app por ele"
+ },
+ "tone": "kernel"
+ }
+ ],
+ "edges": [],
+ "caption": {
+ "en": "All of this is LordOS's own code calling the kernel directly; no container tool is involved.",
+ "es": "Todo esto es código propio de LordOS que llama directamente al kernel; no interviene ninguna herramienta de contenedores.",
+ "pt": "Tudo isso é código próprio do LordOS chamando o kernel diretamente; nenhuma ferramenta de contêiner é usada."
+ }
+ },
+ {
+ "id": "camera",
+ "kind": "flow",
+ "title": {
+ "en": "The camera without handing over the camera",
+ "es": "La cámara sin entregar la cámara",
+ "pt": "A câmera sem entregar a câmera"
+ },
+ "nodes": [
+ {
+ "id": "dev",
+ "label": {
+ "en": "/dev/videoN",
+ "es": "/dev/videoN",
+ "pt": "/dev/videoN"
+ },
+ "sub": {
+ "en": "Opened by lord-server after consent",
+ "es": "Lo abre lord-server después del permiso",
+ "pt": "Aberto pelo lord-server após o consentimento"
+ },
+ "tone": "kernel"
+ },
+ {
+ "id": "media",
+ "label": {
+ "en": "lord-media",
+ "es": "lord-media",
+ "pt": "lord-media"
+ },
+ "sub": {
+ "en": "Sandboxed decoder; frames into a sealed ring",
+ "es": "Decodificador en caja de arena; cuadros a un anillo sellado",
+ "pt": "Decodificador em sandbox; quadros num anel selado"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "ls",
+ "label": {
+ "en": "lord-server",
+ "es": "lord-server",
+ "pt": "lord-server"
+ },
+ "sub": {
+ "en": "Validates every acknowledgement",
+ "es": "Valida cada confirmación",
+ "pt": "Valida cada confirmação"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "app",
+ "label": {
+ "en": "Isolated app",
+ "es": "App aislada",
+ "pt": "App isolado"
+ },
+ "sub": {
+ "en": "Read-only view of the frames",
+ "es": "Vista de solo lectura de los cuadros",
+ "pt": "Visão somente leitura dos quadros"
+ },
+ "tone": "user"
+ }
+ ],
+ "edges": [
+ {
+ "from": "dev",
+ "to": "media",
+ "label": {
+ "en": "device fd",
+ "es": "fd del dispositivo",
+ "pt": "fd do dispositivo"
+ }
+ },
+ {
+ "from": "media",
+ "to": "ls",
+ "label": {
+ "en": "frame ring",
+ "es": "anillo de cuadros",
+ "pt": "anel de quadros"
+ }
+ },
+ {
+ "from": "ls",
+ "to": "app",
+ "label": {
+ "en": "read-only reopen",
+ "es": "reapertura de solo lectura",
+ "pt": "reabertura só leitura"
+ }
+ }
+ ],
+ "caption": {
+ "en": "Revoking the permission kills the app's lord-media and the stream stops at once.",
+ "es": "Revocar el permiso mata el lord-media de la app y la imagen se corta al instante.",
+ "pt": "Revogar a permissão encerra o lord-media do app e a imagem para na hora."
+ }
+ }
+ ],
+ "sources": [
+ {
+ "path": "server/src/sec/sandbox.c",
+ "what": {
+ "en": "Landlock, seccomp, capabilities, network",
+ "es": "Landlock, seccomp, capacidades, red",
+ "pt": "Landlock, seccomp, capacidades, rede"
+ }
+ },
+ {
+ "path": "server/src/sec/brokersrv.c",
+ "what": {
+ "en": "The broker, server side",
+ "es": "El broker, del lado del servidor",
+ "pt": "O broker, lado do servidor"
+ }
+ },
+ {
+ "path": "server/src/sec/perms.c",
+ "what": {
+ "en": "Per-app permissions",
+ "es": "Permisos por app",
+ "pt": "Permissões por app"
+ }
+ },
+ {
+ "path": "server/src/sec/brokercam.c",
+ "what": {
+ "en": "Camera for isolated apps",
+ "es": "Cámara para apps aisladas",
+ "pt": "Câmera para apps isolados"
+ }
+ },
+ {
+ "path": "server/src/sec/cgroup.c",
+ "what": {
+ "en": "Per-app cgroup scopes",
+ "es": "Scopes de cgroup por app",
+ "pt": "Escopos de cgroup por app"
+ }
+ },
+ {
+ "path": "server/src/app/appclient.c",
+ "what": {
+ "en": "The isolated app process",
+ "es": "El proceso de la app aislada",
+ "pt": "O processo do app isolado"
+ }
+ },
+ {
+ "path": "sdk/powerbox.jsx",
+ "what": {
+ "en": "The system file dialog",
+ "es": "El diálogo de archivos del sistema",
+ "pt": "O diálogo de arquivos do sistema"
+ }
+ },
+ {
+ "path": "server/tests/sandbox_test.c",
+ "what": {
+ "en": "Sandbox tests",
+ "es": "Pruebas de la caja de arena",
+ "pt": "Testes do sandbox"
+ }
+ },
+ {
+ "path": "docs/PRIVACY.md",
+ "what": {
+ "en": "Full design notes",
+ "es": "Notas de diseño completas",
+ "pt": "Notas de projeto completas"
+ }
+ }
+ ]
+}
diff --git a/web/content/features/private-by-design.pt.md b/web/content/features/private-by-design.pt.md
new file mode 100644
index 0000000..4ea2d4a
--- /dev/null
+++ b/web/content/features/private-by-design.pt.md
@@ -0,0 +1,109 @@
+## Em poucas palavras
+
+Um app instalável do LordOS (um pacote `.lpk`) não recebe as chaves da sua casa. Ele roda num quarto só dele, com a porta trancada por fora. Quando precisa de algo, pede ao sistema por uma única portinhola, o **broker**. O sistema confere o que você decidiu e, se você ainda não decidiu, pergunta com um aviso desenhado pelo sistema, não pelo app.
+
+[[shot:0]]
+
+Três ideias fazem a maior parte do trabalho:
+
+- **Isolamento.** Cada app `.lpk` é um processo próprio, trancado com recursos do kernel Linux antes que qualquer código dele rode.
+- **Mediação.** Tudo o que toca nas suas coisas (arquivos, câmera, microfone, área de transferência, senhas) passa pelo broker no `lord-server`, que confere a permissão a cada pedido.
+- **Sua decisão, guardada onde o app não alcança.** As decisões ficam em `~/.config/lordos/permisos.json`, que os apps isolados não conseguem ver nem escrever.
+
+[[diagram:permission]]
+
+## Quais apps são isolados, exatamente?
+
+Esta é a primeira pergunta que um leitor atento deve fazer, então aqui vai a resposta precisa:
+
+| Tipo de app | Processo próprio | Sandbox (Landlock + seccomp) | cgroup por app | Broker e permissões | Firewall por app |
+|---|---|---|---|---|---|
+| Apps `.lpk` instalados | sim | sim | sim, com limites de memória e CPU | sim | sim |
+| Senhas (hoje o único app incluído com processo próprio) | sim | sim | sim | sim | sim |
+| Outros apps incluídos (Arquivos, Ajustes, E-mail, Terminal…) | não, rodam dentro do `lord-server` | não | não (contam como "LordOS") | o uso de câmera, microfone e tela é conferido em C | sim, como "LordOS" |
+| Apps Linux abertos pelo lançador de apps (apt, a Loja) | sim, um processo comum | **não** | sim, `app-lordos-<id>.scope`, sem limites | **não** | **sim** |
+| Programas iniciados pelo Terminal | sim | não | dividem o lugar do Terminal na árvore | não | como "LordOS" |
+
+Ou seja: **os apps Linux não ficam em sandbox no LordOS.** Eles rodam como o seu usuário, exatamente como em qualquer sistema Debian, e podem ler sua pasta pessoal. O que o LordOS acrescenta para eles é a atribuição (o Monitor sabe qual app fez cada conexão) e o firewall por app aplicado pelo kernel. O Flatpak não é usado nem integrado pelo LordOS, e não foi testado.
+
+Os apps incluídos fazem parte do código do próprio sistema, revisado junto com ele; eles não recebem o isolamento por processo que os pacotes de terceiros recebem, com Senhas como exceção, porque guarda seus segredos.
+
+## Como o sandbox funciona
+
+O sandbox é código próprio do LordOS (`server/src/sec/sandbox.c`), não bubblewrap, Flatpak nem firejail. Ele usa recursos do kernel diretamente e é aplicado **depois** que o app se conecta ao compositor e ao broker, e **antes** de qualquer linha do código do app ser carregada.
+
+[[diagram:sandbox]]
+
+- **Landlock** limita os arquivos que o processo pode tocar: acesso só de leitura ao próprio pacote, ao runtime compartilhado de apps, às fontes e às bibliotecas; leitura e escrita apenas em `~/.local/share/lordos/appdata/<id>`. Nada mais da sua pasta pessoal, e nada de `/dev`.
+- **seccomp-bpf** é uma lista de chamadas de sistema permitidas, aplicada a todas as threads. Chamadas como `ptrace`, `mount`, `bpf`, `execve`, `keyctl` e carregamento de módulos simplesmente não estão nela. O app também não consegue abrir novos sockets Unix, então não alcança sozinho o barramento da sessão, o serviço de impressão nem o socket Wayland.
+- **Sem privilégios.** `no_new_privs` é ativado e todas as capacidades são removidas.
+- **Um cgroup próprio**, `app-lordos-lpk-<id>.scope`, com limite suave de memória de 192 MB, limite rígido de 512 MB e no máximo um núcleo de CPU. O escopo é criado pelo root (`lord-sessiond`) e pertence a ele, então o app não consegue se mudar para outro lugar.
+- **Rede só com permissão.** Sem a permissão `network`, o seccomp recusa criar sockets de internet e o Landlock recusa connect e bind TCP. Com ela (declarada no manifesto **e** permitida por você), eles são liberados, e o firewall por app continua valendo.
+
+**São usados namespaces?** Não. O `lord-server` roda sem root, e criar um namespace de rede exige privilégios que ele não tem. O projeto usa Landlock, seccomp e cgroups no lugar disso, e deixa o app no namespace de rede da máquina, sob as regras acima.
+
+O projeto mantém um app de teste propositalmente malicioso (`tests/lpk-evil`). Ele não declara nenhuma permissão e tenta de tudo ao abrir: ler `~/.ssh/id_rsa` e `settings.json`, escrever fora da própria pasta, ler a área de transferência escondido, abrir `/etc/shadow`, abrir um socket, executar `/bin/sh`, `ptrace`, abrir a placa de vídeo. Todas as tentativas são bloqueadas. A suíte de testes do sandbox passa em 14 de 14 verificações para apps, 14 de 14 com rede e 17 de 17 para os ajudantes.
+
+[[shot:1]]
+
+## O que você vê e decide
+
+- **O aviso.** Na primeira vez que um app pede algo, o sistema mostra: *"App" quer usar o microfone — Permitir / Não permitir*. A resposta fica salva para aquele app.
+- **Ajustes → Privacidade** lista cada permissão com os apps que a pediram e um controle Permitir / Perguntar / Negar.
+- **Indicadores.** Um ponto verde na barra de menus enquanto a câmera está em uso, e um laranja para o microfone. Ao tocar nele, aparece qual app está usando.
+
+Permissões que um app pode declarar: arquivos, área de transferência, notificações, rede, câmera, microfone, tela, escuta de portas, USB, Bluetooth e apps. Um app não consegue uma permissão que não declarou.
+
+[[shot:4]]
+
+## As perguntas do leitor cético
+
+**Dá para contornar o aviso?** Não pelo app isolado. O aviso é desenhado pela sessão, fora da janela do app. A resposta chega diretamente ao `lord-server`, e o broker lê a decisão salva, em C, a cada pedido. O arquivo de decisões fica fora do que o Landlock deixa o app ver, e o `lord.fs` se recusa a escrevê-lo. Um app até poderia desenhar um diálogo falso dentro da própria janela, mas clicar nele não muda nada. A brecha, sendo honesto: um app Linux, que não tem sandbox e roda como você, poderia editar o `permisos.json` como qualquer outro arquivo da sua pasta pessoal.
+
+**Existe "Permitir uma vez" ou "Permitir sempre"?** Hoje o aviso oferece Permitir e Não permitir, e a decisão fica lembrada até você mudá-la em Ajustes. Ainda não há "permitir uma vez" para as permissões dos apps.
+
+**O app recebe só o arquivo que eu escolho?** Sim. Para abrir ou salvar, um app isolado chama o diálogo de arquivos do sistema. O `lord-server` o desenha (o "powerbox"), abre o arquivo que você escolheu com as suas permissões e passa ao app **só aquele descritor de arquivo**. O app nunca vê a pasta nem o resto do disco. Nenhuma permissão extra é necessária, porque escolher o arquivo já é o consentimento.
+
+[[shot:2]]
+
+**Como a câmera e o microfone são mediados?** O app nunca abre o dispositivo.
+- *Microfone:* o `lord-server` abre o fluxo de captura do PipeWire e escreve o áudio num anel compartilhado; o app recebe uma cópia **somente leitura** dele.
+- *Câmera:* o `lord-server` abre `/dev/videoN` e o entrega só ao ajudante de mídia em sandbox, o `lord-media`, que decodifica os quadros num anel compartilhado e selado. O app recebe um mapeamento somente leitura e precisa confirmar cada quadro; o `lord-server` valida cada confirmação (geração, posição, ritmo). Fotos e vídeos vão para um arquivo que você escolhe no diálogo de salvar do sistema.
+
+[[diagram:camera]]
+
+**Dá para revogar permissões com o app aberto?** Sim, para a câmera e o microfone: colocar qualquer um deles em Perguntar ou Negar em Ajustes corta na hora. No caso da câmera, o `lord-server` encerra o processo `lord-media` do app (testado: some em até 0,5 s); no do microfone, fecha o fluxo do PipeWire. Verificações como a da área de transferência valem a partir do próximo pedido. A permissão `network` é decidida quando o app inicia, então uma mudança vale no próximo lançamento; para tirar da rede um app que já está rodando na hora, use o botão do firewall no Monitor.
+
+[[shot:3]]
+
+**E os apps que precisam de mais privilégios?** Não há como um app `.lpk` obter root ou capacidades extras. Tudo no LordOS que precisa de root passa por uma lista fechada de ações validadas (`server/src/admin.c`), e o JavaScript não consegue executar comandos arbitrários. Os apps Linux se comportam como em qualquer sistema Debian: se um programa precisa de `sudo`, você mesmo o executa no Terminal.
+
+## Os ajudantes que leem dados não confiáveis
+
+Arquivos vindos de fora são a porta de entrada clássica. O LordOS os abre em pequenos processos separados, trancados com ainda mais rigor que os apps: `lord-doc` (PDFs, arquivos compactados, fontes), `lord-media` (vídeo, música, fotos, câmera), `lord-maild` (e-mail, calendários, contatos) e `lord-vault` (senhas). Eles não têm rede, não conseguem criar sockets, não conseguem executar programas e só podem criar threads, não processos. Eles não abrem caminhos: o `lord-server` abre os arquivos e os passa como descritores. Se o seccomp não puder ser aplicado, o ajudante encerra em vez de rodar sem confinamento. Um PDF malicioso pode derrubar o `lord-doc`, mas não o desktop.
+
+## Janelas protegidas
+
+Uma janela pode ser marcada como protegida. A de Senhas é. Os pixels dela saem pretos nas capturas de tela do LordOS, nas gravações de tela, nas miniaturas e na área de trabalho remota, enquanto o monitor de verdade a mostra normalmente. Os apps Linux não conseguem capturar a tela pelo LordOS: o compositor não oferece a eles nenhum protocolo de captura de tela.
+
+[[shot:5]]
+
+## Limites honestos
+
+- **Os apps Linux não têm sandbox.** Para eles valem apenas as regras de rede e a atribuição.
+- **O uso de câmera e microfone por apps Linux ainda não aparece** nos indicadores. A lista de dispositivos do Monitor está planejada.
+- **Algumas "restrições" do firewall ainda não são aplicadas.** Ajustes deixa marcar "Sem câmera", "Sem microfone", "Sem captura de tela", "Sem USB", "Sem Bluetooth", "Sem arquivos fora do seletor" e "Sem notificações" para um app. Elas ficam salvas, mas hoje nenhum componente as confere; só as quatro restrições de rede são aplicadas. Para câmera e microfone, use a própria permissão (Negar), que é aplicada.
+- **O broker ainda não cobre tudo.** Permissões como Bluetooth ou abrir outros apps podem ser declaradas, mas não há chamada do broker para elas, então um app isolado simplesmente não consegue fazer essas coisas.
+- **A falta de um recurso do kernel enfraquece o sandbox dos apps sem alarde.** Se faltar o Landlock ou um controlador de cgroup, os apps iniciam mesmo assim, com um aviso no log. Já os ajudantes se recusam a rodar sem seccomp.
+
+## Leia o código
+
+- [server/src/sec/sandbox.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/sandbox.c): Landlock, seccomp, capacidades, regras de rede
+- [server/src/sec/brokersrv.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/brokersrv.c): o broker, lado do servidor
+- [server/src/sec/perms.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/perms.c): permissões por app
+- [server/src/sec/brokercam.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/brokercam.c): a câmera para apps isolados
+- [server/src/sec/cgroup.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/cgroup.c) e [server/src/remote/cgsup.c](https://github.com/lordbasex/LordOS/blob/main/server/src/remote/cgsup.c): escopos dos apps que pertencem ao root
+- [server/src/app/appclient.c](https://github.com/lordbasex/LordOS/blob/main/server/src/app/appclient.c): o processo do app isolado
+- [sdk/privacy.js](https://github.com/lordbasex/LordOS/blob/main/sdk/privacy.js) e [sdk/powerbox.jsx](https://github.com/lordbasex/LordOS/blob/main/sdk/powerbox.jsx): avisos e o diálogo de arquivos
+- [server/tests/sandbox_test.c](https://github.com/lordbasex/LordOS/blob/main/server/tests/sandbox_test.c) e [tests/lpk-evil](https://github.com/lordbasex/LordOS/tree/main/tests/lpk-evil): os testes
+- [docs/PRIVACY.md](https://github.com/lordbasex/LordOS/blob/main/docs/PRIVACY.md)
diff --git a/web/content/features/visible-firewall.en.md b/web/content/features/visible-firewall.en.md
new file mode 100644
index 0000000..018a71e
--- /dev/null
+++ b/web/content/features/visible-firewall.en.md
@@ -0,0 +1,87 @@
+## The short version
+
+Most firewalls think in terms of ports and addresses. LordOS's firewall thinks in terms of **apps**: you decide which of your apps may use the network, and how much of it. And because it is built into the Monitor, you can see what each app is doing before you decide.
+
+[[shot:0]]
+
+Picture a building with a guard at every apartment door instead of one at the street. When an app tries to open a connection, the guard at its door checks its list in a fraction of a microsecond and either lets it through or answers "not permitted". The guard sits inside the Linux kernel, so a determined app can't simply walk around it.
+
+[[diagram:path]]
+
+## What you see and decide
+
+- **Monitor → Network** lists the apps with connections, how much each one sent and received, and a world map with an arc to each country they talk to. Each app has a **Rule** switch: turn it off and the app is denied the network at once, with allowed and denied counters coming straight from the kernel.
+- **Settings → Privacy → App network access** has a mode and two lists:
+ - **Silent** (the default): whatever has no rule is allowed and recorded, so you can review it in the Monitor. **Off**: only your explicit denials and restrictions apply.
+ - **Trusted apps**: allowed without recording. An explicit denial you set still wins.
+ - **Restricted apps**: tick what an app may not do. The network restrictions are **no internet** (LAN only), **no LAN**, **no network at all** and **no incoming connections**.
+
+[[shot:1]]
+
+[[shot:2]]
+
+## How it works
+
+**1. Every app has a name the kernel can see.** When you open a Linux app from the app launcher, `lord-server` asks root to place it in its own cgroup, `app-lordos-<id>.scope`. Installed `.lpk` apps get `app-lordos-lpk-<id>.scope`. These scopes are created and owned by root, so an app can't move itself to another one.
+
+**2. A small root service enforces the rules.** `lord-netperm` loads seven eBPF programs into the cgroup of the LordOS service, which contains every session:
+
+| Kernel hook | What it checks |
+|---|---|
+| `connect4`, `connect6` | TCP and connected UDP |
+| `sendmsg4`, `sendmsg6` | UDP sent with an address |
+| `bind4`, `bind6` | incoming: "no incoming connections" and inbound rules |
+| `sock_create` | "no network": the app can't even create an internet socket |
+
+Each program finds which app the calling process belongs to (by the cgroup ancestor at the scope level, so child processes count as the same app), decides, and returns allow or deny. A denied app gets `EPERM`, "Operation not permitted".
+
+[[shot:4]]
+
+**3. Your rules become kernel maps.** You change rules in the session; `lord-server` saves them to `~/.config/lordos/firewall.json` and sends `lord-netperm` a single message with no data: `RELOAD`. The service then reads the file itself, strictly validated, and compiles the rules into hash and longest-prefix-match maps. The rules never travel over the socket.
+
+**4. Nothing runs per packet.** The checks run when a connection is opened or a port is bound, not for every packet. Measured on a test VM: about **0.5 µs** per UDP connect, TCP within noise, and no change in throughput (`docs/FIREWALL.md`).
+
+## Does it work per domain?
+
+The engine does, with care about where names come from. A connection only carries an IP address, so to apply a rule like "allow only `example.com`", the firewall must know which names an address belongs to. It learns that **only from the system resolver**: it subscribes to systemd-resolved's monitor (or, without it, reads replies from port 53 of the servers in `/etc/resolv.conf`). It never trusts DNS answers an app received on its own sockets, which a malicious app could forge.
+
+[[diagram:dns]]
+
+On the test VM, "deny everything except example.com" let `https://example.com` through and denied `https://www.debian.org`, 20 out of 20 times even with an empty resolver cache. An app that uses its own DNS-over-HTTPS gets addresses the firewall never learned, so under such a rule they are denied.
+
+What is **not** there yet: a screen to write domain rules. The rule engine and the `lord.fw.addRule` API support domains, wildcards, networks, ports and protocols, but the interface today offers the per-app switch and the restriction lists. Per-destination switches in the Monitor are planned.
+
+## The skeptical reader's questions
+
+**Does it apply to Linux apps too?** Yes. That is one of its main points: Chromium, Firefox or any app opened from the app launcher has its own scope and its own rules. Built-in LordOS apps and programs started from the Terminal count together as "LordOS".
+
+**Can an app escape its scope?** It was tried. A Linux app can't write itself into another cgroup, because every `cgroup.procs` file in the session's tree belongs to root. It can still ask the user's systemd manager to start a new process outside the tree (`systemd-run --user`). LordOS closes that too: `lord-netperm` also attaches its programs to each user's `user@<uid>.service`, and any process there is held to the strictest union of the restrictions of that user's running restricted apps. Tested with `systemd-run --user --scope`, a transient service and `setsid`: all denied.
+
+[[shot:3]]
+
+**Can I allow a connection just once, or be asked?** The rule engine knows three durations (forever, until the app quits, just once) and an "ask" mode, but the ask prompt isn't built yet: today "ask" behaves like silent. It is designed as a retry prompt: the first connection is denied, you get *Allow once / Always / Deny*, and the app's retry goes through.
+
+**What happens if the service stops?** Its links are closed and everything is allowed. The desktop doesn't depend on it. On the final ISO the service was running with its seven programs attached.
+
+**Is the service itself dangerous?** It is kept small on purpose: it runs no programs, takes no arguments, has no internet sockets of its own (its unit only allows Unix and packet sockets), and accepts one message type. It uses its own loader over the `bpf()` system call, with the programs compiled into the binary; no libbpf or bcc.
+
+## Honest limits
+
+- **ICMP** (ping) is only blocked by "no network". **Incoming connections to a port that is already open**, and `listen` without `bind`, aren't checked: that would need a per-packet hook.
+- **The `user@` union is coarse:** while a restricted app runs, every process in that user's systemd manager is held to the union of restrictions.
+- **A brand-new scope** is registered within microseconds, but a connection made before that would pass under default rules.
+- **Host names aren't shown in the Monitor yet**, only IPs and countries. The Monitor never does reverse DNS, so no address leaves the machine just because you looked at it.
+- **Non-network restrictions** (camera, microphone, screen, USB, Bluetooth, files, notifications) can be ticked in Settings but **aren't enforced yet**: only the four network restrictions are. Use the per-app permissions for the camera and the microphone.
+- **The rules file can be edited by unsandboxed Linux apps**, since they run as you. Installed `.lpk` apps can't reach it.
+
+## Read the source
+
+- [server/src/netperm/np.bpf.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/np.bpf.c): the seven cgroup eBPF programs
+- [server/src/netperm/netperm.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/netperm.c): the root service
+- [server/src/netperm/npcompile.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/npcompile.c): rules into kernel maps
+- [server/src/netperm/npdns.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/npdns.c): names from the system resolver
+- [server/src/fw/rules.c](https://github.com/lordbasex/LordOS/blob/main/server/src/fw/rules.c): rules, precedence and the strict file reader
+- [server/src/ui/js_fw.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/js_fw.c): `lord.fw`, the session API
+- [apps/monitor/Firewall.jsx](https://github.com/lordbasex/LordOS/blob/main/apps/monitor/Firewall.jsx): the Settings section
+- [server/tests/netperm_integration.sh](https://github.com/lordbasex/LordOS/blob/main/server/tests/netperm_integration.sh): the kernel test, 18 of 18
+- [docs/FIREWALL.md](https://github.com/lordbasex/LordOS/blob/main/docs/FIREWALL.md) and [docs/MONITOR.md](https://github.com/lordbasex/LordOS/blob/main/docs/MONITOR.md)
diff --git a/web/content/features/visible-firewall.es.md b/web/content/features/visible-firewall.es.md
new file mode 100644
index 0000000..6c226a5
--- /dev/null
+++ b/web/content/features/visible-firewall.es.md
@@ -0,0 +1,87 @@
+## En pocas palabras
+
+La mayoría de los firewalls piensan en puertos y direcciones. El firewall de LordOS piensa en **apps**: vos decidís cuáles de tus apps pueden usar la red, y cuánto. Y como está integrado al Monitor, podés ver qué está haciendo cada app antes de decidir.
+
+[[shot:0]]
+
+Imaginate un edificio con un guardia en la puerta de cada departamento en lugar de uno solo en la calle. Cuando una app intenta abrir una conexión, el guardia de su puerta revisa su lista en una fracción de microsegundo y la deja pasar o le contesta "no permitido". El guardia está dentro del kernel Linux, así que una app insistente no puede simplemente rodearlo.
+
+[[diagram:path]]
+
+## Qué ves y qué decidís
+
+- **Monitor → Red** lista las apps con conexiones, cuánto mandó y recibió cada una, y un mapa del mundo con un arco hacia cada país con el que hablan. Cada app tiene un interruptor de **Regla**: si lo apagás, a la app se le niega la red al instante, con contadores de conexiones permitidas y denegadas que salen directo del kernel.
+- **Ajustes → Privacidad → Red de las apps** tiene un modo y dos listas:
+ - **Silencioso** (el predeterminado): lo que no tiene regla se permite y se registra, para que lo revises en el Monitor. **Apagado**: solo valen tus denegaciones explícitas y las restricciones.
+ - **Apps confiables**: se permiten sin registrar. Una denegación explícita que pongas igual gana.
+ - **Apps restringidas**: marcás lo que una app no puede hacer. Las restricciones de red son **sin internet** (solo LAN), **sin LAN**, **sin red** y **sin conexiones entrantes**.
+
+[[shot:1]]
+
+[[shot:2]]
+
+## Cómo funciona
+
+**1. Cada app tiene un nombre que el kernel puede ver.** Cuando abrís una app de Linux desde el lanzador de apps, `lord-server` le pide a root que la ubique en su propio cgroup, `app-lordos-<id>.scope`. Las apps `.lpk` instaladas reciben `app-lordos-lpk-<id>.scope`. Estos scopes los crea y los tiene root, así que una app no se puede mudar a otro.
+
+**2. Un servicio root chico aplica las reglas.** `lord-netperm` carga siete programas eBPF en el cgroup del servicio de LordOS, que contiene todas las sesiones:
+
+| Gancho del kernel | Qué revisa |
+|---|---|
+| `connect4`, `connect6` | TCP y UDP conectado |
+| `sendmsg4`, `sendmsg6` | UDP enviado con una dirección |
+| `bind4`, `bind6` | entrantes: "sin conexiones entrantes" y reglas de entrada |
+| `sock_create` | "sin red": la app ni siquiera puede crear un socket de internet |
+
+Cada programa averigua a qué app pertenece el proceso que llama (por el cgroup ancestro al nivel del scope, así que los procesos hijos cuentan como la misma app), decide y devuelve permitir o denegar. Una app denegada recibe `EPERM`, "Operation not permitted".
+
+[[shot:4]]
+
+**3. Tus reglas se convierten en mapas del kernel.** Cambiás las reglas en la sesión; `lord-server` las guarda en `~/.config/lordos/firewall.json` y le manda a `lord-netperm` un único mensaje sin datos: `RELOAD`. Después el servicio lee el archivo por su cuenta, con validación estricta, y compila las reglas en mapas hash y de coincidencia por prefijo más largo. Las reglas nunca viajan por el socket.
+
+**4. Nada corre por paquete.** Los controles corren cuando se abre una conexión o se reserva un puerto, no en cada paquete. Medido en una VM de prueba: unos **0,5 µs** por connect UDP, TCP dentro del ruido, y sin cambios en el rendimiento (`docs/FIREWALL.md`).
+
+## ¿Funciona por dominio?
+
+El motor sí, con cuidado sobre de dónde salen los nombres. Una conexión solo lleva una dirección IP, así que para aplicar una regla como "permitir solo `example.com`" el firewall tiene que saber a qué nombres corresponde una dirección. Eso lo aprende **solo del resolvedor del sistema**: se suscribe al monitor de systemd-resolved (o, sin él, lee las respuestas del puerto 53 de los servidores de `/etc/resolv.conf`). Nunca confía en respuestas DNS que una app recibió en sus propios sockets, que una app maliciosa podría falsificar.
+
+[[diagram:dns]]
+
+En la VM de prueba, "denegar todo menos example.com" dejó pasar `https://example.com` y denegó `https://www.debian.org`, 20 de 20 veces incluso con la caché del resolvedor vacía. Una app que usa su propio DNS sobre HTTPS obtiene direcciones que el firewall nunca aprendió, así que bajo una regla así quedan denegadas.
+
+Lo que **todavía no** está: una pantalla para escribir reglas por dominio. El motor de reglas y la API `lord.fw.addRule` soportan dominios, comodines, redes, puertos y protocolos, pero la interfaz hoy ofrece el interruptor por app y las listas de restricciones. Los interruptores por destino en el Monitor están planeados.
+
+## Las preguntas del lector escéptico
+
+**¿Se aplica también a las apps de Linux?** Sí. Es uno de sus puntos principales: Chromium, Firefox o cualquier app abierta desde el lanzador de apps tiene su propio scope y sus propias reglas. Las apps incluidas de LordOS y los programas iniciados desde la Terminal cuentan juntos como "LordOS".
+
+**¿Puede una app escaparse de su scope?** Se probó. Una app de Linux no puede anotarse en otro cgroup, porque cada archivo `cgroup.procs` del árbol de la sesión es de root. Todavía puede pedirle al gestor systemd del usuario que arranque un proceso nuevo fuera del árbol (`systemd-run --user`). LordOS también cierra eso: `lord-netperm` engancha además sus programas al `user@<uid>.service` de cada usuario, y cualquier proceso ahí queda sujeto a la unión más estricta de las restricciones de las apps restringidas que ese usuario tenga corriendo. Probado con `systemd-run --user --scope`, un servicio transitorio y `setsid`: todos denegados.
+
+[[shot:3]]
+
+**¿Puedo permitir una conexión una sola vez, o que me pregunte?** El motor de reglas conoce tres duraciones (para siempre, hasta que la app se cierre, una sola vez) y un modo "preguntar", pero el aviso de preguntar todavía no está hecho: hoy "preguntar" se comporta como silencioso. Está diseñado como un aviso de reintento: la primera conexión se deniega, te aparece *Permitir una vez / Siempre / Denegar*, y el reintento de la app pasa.
+
+**¿Qué pasa si el servicio se detiene?** Se cierran sus enganches y todo queda permitido. El escritorio no depende de él. En la ISO final el servicio estaba corriendo con sus siete programas enganchados.
+
+**¿El servicio en sí es peligroso?** Se lo mantiene chico a propósito: no ejecuta programas, no recibe argumentos, no tiene sockets de internet propios (su unidad solo permite sockets Unix y de paquetes) y acepta un solo tipo de mensaje. Usa su propio cargador sobre la llamada al sistema `bpf()`, con los programas compilados dentro del binario; sin libbpf ni bcc.
+
+## Límites honestos
+
+- **ICMP** (ping) solo se bloquea con "sin red". **Las conexiones entrantes a un puerto que ya está abierto**, y `listen` sin `bind`, no se revisan: eso necesitaría un gancho por paquete.
+- **La unión de `user@` es gruesa:** mientras corre una app restringida, cada proceso del gestor systemd de ese usuario queda sujeto a la unión de restricciones.
+- **Un scope recién creado** se registra en microsegundos, pero una conexión hecha antes pasaría con las reglas predeterminadas.
+- **Los nombres de host todavía no se muestran en el Monitor**, solo IPs y países. El Monitor nunca hace DNS inverso, así que ninguna dirección sale de la máquina solo porque la miraste.
+- **Las restricciones que no son de red** (cámara, micrófono, pantalla, USB, Bluetooth, archivos, notificaciones) se pueden marcar en Ajustes pero **todavía no se aplican**: solo se aplican las cuatro restricciones de red. Para la cámara y el micrófono, usá los permisos por app.
+- **Las apps de Linux sin caja de arena pueden editar el archivo de reglas**, porque corren como vos. Las apps `.lpk` instaladas no llegan a él.
+
+## Leé el código
+
+- [server/src/netperm/np.bpf.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/np.bpf.c): los siete programas eBPF de cgroup
+- [server/src/netperm/netperm.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/netperm.c): el servicio root
+- [server/src/netperm/npcompile.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/npcompile.c): las reglas convertidas en mapas del kernel
+- [server/src/netperm/npdns.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/npdns.c): los nombres desde el resolvedor del sistema
+- [server/src/fw/rules.c](https://github.com/lordbasex/LordOS/blob/main/server/src/fw/rules.c): reglas, precedencia y el lector estricto del archivo
+- [server/src/ui/js_fw.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/js_fw.c): `lord.fw`, la API de la sesión
+- [apps/monitor/Firewall.jsx](https://github.com/lordbasex/LordOS/blob/main/apps/monitor/Firewall.jsx): la sección de Ajustes
+- [server/tests/netperm_integration.sh](https://github.com/lordbasex/LordOS/blob/main/server/tests/netperm_integration.sh): la prueba con el kernel, 18 de 18
+- [docs/FIREWALL.md](https://github.com/lordbasex/LordOS/blob/main/docs/FIREWALL.md) y [docs/MONITOR.md](https://github.com/lordbasex/LordOS/blob/main/docs/MONITOR.md)
diff --git a/web/content/features/visible-firewall.meta.json b/web/content/features/visible-firewall.meta.json
new file mode 100644
index 0000000..7a5f7b1
--- /dev/null
+++ b/web/content/features/visible-firewall.meta.json
@@ -0,0 +1,348 @@
+{
+ "slug": "visible-firewall",
+ "order": 3,
+ "title": {
+ "en": "A firewall you can see",
+ "es": "Un firewall que podés ver",
+ "pt": "Um firewall que você pode ver"
+ },
+ "tagline": {
+ "en": "See every app's connections on a live map, then allow, block or limit each app, enforced in the kernel.",
+ "es": "Mirá las conexiones de cada app en un mapa en vivo y después permití, bloqueá o limitá cada app, con reglas que aplica el kernel.",
+ "pt": "Veja as conexões de cada app num mapa ao vivo e depois permita, bloqueie ou limite cada app, com regras aplicadas pelo kernel."
+ },
+ "lumo": {
+ "pose": "shield",
+ "intro": {
+ "en": "This is my favourite room: the map! I watch every app that talks to the internet, and when you say an app may not, I make sure the kernel itself says no.",
+ "es": "Esta es mi habitación favorita: ¡el mapa! Vigilo cada app que habla con internet, y cuando decís que una app no puede, me aseguro de que el propio kernel diga que no.",
+ "pt": "Este é meu cômodo favorito: o mapa! Eu vigio cada app que fala com a internet, e quando você diz que um app não pode, garanto que o próprio kernel diga não."
+ }
+ },
+ "screenshots": [
+ {
+ "file": "docs/screenshots/monitor-network-map.png",
+ "caption": {
+ "en": "Monitor → Network: apps on the left, their destinations on a world map, the summary on the right.",
+ "es": "Monitor → Red: las apps a la izquierda, sus destinos en un mapa del mundo y el resumen a la derecha.",
+ "pt": "Monitor → Rede: os apps à esquerda, os destinos num mapa-múndi e o resumo à direita."
+ }
+ },
+ {
+ "file": "docs/firewall-monitor-denied.png",
+ "caption": {
+ "en": "The Rule switch set to deny for one app, with the kernel's allowed and denied counters.",
+ "es": "El interruptor de Regla en denegar para una app, con los contadores de permitidas y denegadas del kernel.",
+ "pt": "O botão de Regra em negar para um app, com os contadores de permitidas e negadas do kernel."
+ }
+ },
+ {
+ "file": "docs/firewall-settings.png",
+ "caption": {
+ "en": "Settings → Privacy → App network access: the mode, Trusted apps and Restricted apps.",
+ "es": "Ajustes → Red de las apps: el modo, las apps de confianza y las restringidas.",
+ "pt": "Ajustes → Rede dos apps: o modo, os apps confiáveis e os restritos."
+ }
+ },
+ {
+ "file": "docs/firewall-escape-blocked.png",
+ "caption": {
+ "en": "Escape attempts through the user's service manager, all denied.",
+ "es": "Intentos de escape a través del gestor de servicios del usuario, todos denegados.",
+ "pt": "Tentativas de fuga pelo gerenciador de serviços do usuário, todas negadas."
+ }
+ },
+ {
+ "file": "docs/firewall-app-denied.png",
+ "caption": {
+ "en": "A denied app: its commands get \"Operation not permitted\".",
+ "es": "Una app denegada: sus comandos reciben \"Operation not permitted\".",
+ "pt": "Um app negado: os comandos recebem \"Operation not permitted\"."
+ }
+ }
+ ],
+ "diagrams": [
+ {
+ "id": "path",
+ "kind": "flow",
+ "title": {
+ "en": "The path of a connection",
+ "es": "El camino de una conexión",
+ "pt": "O caminho de uma conexão"
+ },
+ "nodes": [
+ {
+ "id": "socket",
+ "label": {
+ "en": "App opens a connection",
+ "es": "La app abre una conexión",
+ "pt": "O app abre uma conexão"
+ },
+ "sub": {
+ "en": "connect, sendto, bind or socket",
+ "es": "connect, sendto, bind o socket",
+ "pt": "connect, sendto, bind ou socket"
+ },
+ "tone": "user"
+ },
+ {
+ "id": "hook",
+ "label": {
+ "en": "cgroup eBPF hook",
+ "es": "Gancho eBPF de cgroup",
+ "pt": "Gancho eBPF de cgroup"
+ },
+ "sub": {
+ "en": "In the kernel; finds the app by its scope",
+ "es": "En el kernel; reconoce la app por su scope",
+ "pt": "No kernel; reconhece o app pelo escopo"
+ },
+ "tone": "kernel"
+ },
+ {
+ "id": "rule",
+ "label": {
+ "en": "Per-app rules",
+ "es": "Reglas por app",
+ "pt": "Regras por app"
+ },
+ "sub": {
+ "en": "Restrictions, then the most specific rule, then trusted, then mode",
+ "es": "Restricciones, luego la regla más específica, luego confianza, luego el modo",
+ "pt": "Restrições, depois a regra mais específica, depois confiança, depois o modo"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "verdict",
+ "label": {
+ "en": "Allow or deny",
+ "es": "Permitir o denegar",
+ "pt": "Permitir ou negar"
+ },
+ "sub": {
+ "en": "Denied: the app gets EPERM",
+ "es": "Denegada: la app recibe EPERM",
+ "pt": "Negada: o app recebe EPERM"
+ },
+ "tone": "deny"
+ },
+ {
+ "id": "monitor",
+ "label": {
+ "en": "Monitor map",
+ "es": "Mapa del Monitor",
+ "pt": "Mapa do Monitor"
+ },
+ "sub": {
+ "en": "New connections and counters, once per second",
+ "es": "Conexiones nuevas y contadores, una vez por segundo",
+ "pt": "Conexões novas e contadores, uma vez por segundo"
+ },
+ "tone": "ours"
+ }
+ ],
+ "edges": [
+ {
+ "from": "socket",
+ "to": "hook",
+ "label": {
+ "en": "system call",
+ "es": "llamada al sistema",
+ "pt": "chamada de sistema"
+ }
+ },
+ {
+ "from": "hook",
+ "to": "rule",
+ "label": {
+ "en": "map lookup",
+ "es": "búsqueda en el mapa",
+ "pt": "consulta ao mapa"
+ }
+ },
+ {
+ "from": "rule",
+ "to": "verdict",
+ "label": {
+ "en": "decision",
+ "es": "decisión",
+ "pt": "decisão"
+ }
+ },
+ {
+ "from": "verdict",
+ "to": "monitor",
+ "label": {
+ "en": "ring buffer",
+ "es": "anillo de eventos",
+ "pt": "anel de eventos"
+ }
+ }
+ ],
+ "caption": {
+ "en": "The decision happens in the kernel when the connection opens; nothing runs per packet.",
+ "es": "La decisión ocurre en el kernel cuando se abre la conexión; nada corre por cada paquete.",
+ "pt": "A decisão acontece no kernel quando a conexão abre; nada roda por pacote."
+ }
+ },
+ {
+ "id": "dns",
+ "kind": "flow",
+ "title": {
+ "en": "Where domain names come from",
+ "es": "De dónde salen los nombres de dominio",
+ "pt": "De onde vêm os nomes de domínio"
+ },
+ "nodes": [
+ {
+ "id": "resolver",
+ "label": {
+ "en": "System resolver",
+ "es": "Resolvedor del sistema",
+ "pt": "Resolvedor do sistema"
+ },
+ "sub": {
+ "en": "systemd-resolved, or replies from port 53 of the configured servers",
+ "es": "systemd-resolved, o respuestas del puerto 53 de los servidores configurados",
+ "pt": "systemd-resolved, ou respostas da porta 53 dos servidores configurados"
+ },
+ "tone": "reused"
+ },
+ {
+ "id": "reader",
+ "label": {
+ "en": "Strict DNS reader",
+ "es": "Lector DNS estricto",
+ "pt": "Leitor DNS estrito"
+ },
+ "sub": {
+ "en": "Only the chain that follows from the question",
+ "es": "Solo la cadena que sale de la pregunta",
+ "pt": "Só a cadeia que decorre da pergunta"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "maps",
+ "label": {
+ "en": "Address entries",
+ "es": "Entradas por dirección",
+ "pt": "Entradas por endereço"
+ },
+ "sub": {
+ "en": "One kernel map node per learned address",
+ "es": "Un nodo del mapa del kernel por dirección aprendida",
+ "pt": "Um nó do mapa do kernel por endereço aprendido"
+ },
+ "tone": "kernel"
+ },
+ {
+ "id": "nope",
+ "label": {
+ "en": "App's own DNS",
+ "es": "DNS propio de la app",
+ "pt": "DNS próprio do app"
+ },
+ "sub": {
+ "en": "Never learned: such addresses don't match an allow rule",
+ "es": "Nunca se aprende: esas direcciones no coinciden con una regla de permitir",
+ "pt": "Nunca é aprendido: esses endereços não batem com regra de permitir"
+ },
+ "tone": "deny"
+ }
+ ],
+ "edges": [
+ {
+ "from": "resolver",
+ "to": "reader",
+ "label": {
+ "en": "answers",
+ "es": "respuestas",
+ "pt": "respostas"
+ }
+ },
+ {
+ "from": "reader",
+ "to": "maps",
+ "label": {
+ "en": "name → IP",
+ "es": "nombre → IP",
+ "pt": "nome → IP"
+ }
+ }
+ ],
+ "caption": {
+ "en": "Domain rules trust only answers the system resolver received, never packets an app received itself.",
+ "es": "Las reglas por dominio solo confían en respuestas que recibió el resolvedor del sistema, nunca en paquetes que recibió la app.",
+ "pt": "Regras por domínio só confiam em respostas recebidas pelo resolvedor do sistema, nunca em pacotes recebidos pelo próprio app."
+ }
+ }
+ ],
+ "sources": [
+ {
+ "path": "server/src/netperm/np.bpf.c",
+ "what": {
+ "en": "The cgroup eBPF programs",
+ "es": "Los programas eBPF de cgroup",
+ "pt": "Os programas eBPF de cgroup"
+ }
+ },
+ {
+ "path": "server/src/netperm/netperm.c",
+ "what": {
+ "en": "The root service lord-netperm",
+ "es": "El servicio root lord-netperm",
+ "pt": "O serviço root lord-netperm"
+ }
+ },
+ {
+ "path": "server/src/netperm/npcompile.c",
+ "what": {
+ "en": "Rules compiled into kernel maps",
+ "es": "Reglas compiladas a mapas del kernel",
+ "pt": "Regras compiladas em mapas do kernel"
+ }
+ },
+ {
+ "path": "server/src/netperm/npdns.c",
+ "what": {
+ "en": "Names from the system resolver",
+ "es": "Nombres desde el resolvedor del sistema",
+ "pt": "Nomes do resolvedor do sistema"
+ }
+ },
+ {
+ "path": "server/src/fw/rules.c",
+ "what": {
+ "en": "Rules, precedence and the file reader",
+ "es": "Reglas, precedencia y lector del archivo",
+ "pt": "Regras, precedência e leitor do arquivo"
+ }
+ },
+ {
+ "path": "server/src/ui/js_fw.c",
+ "what": {
+ "en": "lord.fw, the session API",
+ "es": "lord.fw, la API de la sesión",
+ "pt": "lord.fw, a API da sessão"
+ }
+ },
+ {
+ "path": "server/tests/netperm_integration.sh",
+ "what": {
+ "en": "Kernel integration test",
+ "es": "Prueba de integración con el kernel",
+ "pt": "Teste de integração com o kernel"
+ }
+ },
+ {
+ "path": "docs/FIREWALL.md",
+ "what": {
+ "en": "Full design and measurements",
+ "es": "Diseño completo y mediciones",
+ "pt": "Projeto completo e medições"
+ }
+ }
+ ]
+}
diff --git a/web/content/features/visible-firewall.pt.md b/web/content/features/visible-firewall.pt.md
new file mode 100644
index 0000000..29077ea
--- /dev/null
+++ b/web/content/features/visible-firewall.pt.md
@@ -0,0 +1,87 @@
+## Em poucas palavras
+
+A maioria dos firewalls pensa em portas e endereços. O firewall do LordOS pensa em **apps**: você decide quais dos seus apps podem usar a rede, e quanto dela. E, como ele está integrado ao Monitor, você vê o que cada app está fazendo antes de decidir.
+
+[[shot:0]]
+
+Imagine um prédio com um porteiro na porta de cada apartamento, em vez de um só na entrada da rua. Quando um app tenta abrir uma conexão, o porteiro da porta dele confere a lista numa fração de microssegundo e deixa passar ou responde "não permitido". O porteiro fica dentro do kernel Linux, então um app insistente não consegue simplesmente dar a volta nele.
+
+[[diagram:path]]
+
+## O que você vê e decide
+
+- **Monitor → Rede** lista os apps com conexões, quanto cada um enviou e recebeu, e um mapa-múndi com um arco até cada país com que eles falam. Cada app tem um botão de **Regra**: desligue e o app perde a rede na hora, com contadores de conexões permitidas e negadas vindos direto do kernel.
+- **Ajustes → Privacidade → Rede dos apps** tem um modo e duas listas:
+ - **Silencioso** (o padrão): o que não tem regra é permitido e fica anotado, para você revisar no Monitor. **Desligado**: só valem as suas negações explícitas e as restrições.
+ - **Apps confiáveis**: permitidos sem anotação. Uma negação explícita que você definiu continua valendo.
+ - **Apps restritos**: marque o que um app não pode fazer. As restrições de rede são **Sem internet** (só LAN), **Sem LAN**, **Sem rede** nenhuma e **Sem conexões de entrada**.
+
+[[shot:1]]
+
+[[shot:2]]
+
+## Como funciona
+
+**1. Todo app tem um nome que o kernel enxerga.** Quando você abre um app Linux pelo lançador de apps, o `lord-server` pede ao root que o coloque num cgroup próprio, `app-lordos-<id>.scope`. Os apps `.lpk` instalados ganham `app-lordos-lpk-<id>.scope`. Esses escopos são criados pelo root e pertencem a ele, então um app não consegue se mudar para outro.
+
+**2. Um pequeno serviço root aplica as regras.** O `lord-netperm` carrega sete programas eBPF no cgroup do serviço do LordOS, que contém todas as sessões:
+
+| Gancho do kernel | O que confere |
+|---|---|
+| `connect4`, `connect6` | TCP e UDP conectado |
+| `sendmsg4`, `sendmsg6` | UDP enviado com endereço |
+| `bind4`, `bind6` | entrada: "sem conexões de entrada" e regras de entrada |
+| `sock_create` | "sem rede": o app nem consegue criar um socket de internet |
+
+Cada programa descobre a qual app pertence o processo que chamou (pelo ancestral do cgroup no nível do escopo, então processos filhos contam como o mesmo app), decide e devolve permitir ou negar. Um app negado recebe `EPERM`, "Operation not permitted".
+
+[[shot:4]]
+
+**3. Suas regras viram mapas do kernel.** Você muda as regras na sessão; o `lord-server` as salva em `~/.config/lordos/firewall.json` e manda ao `lord-netperm` uma única mensagem sem dados: `RELOAD`. O serviço então lê o arquivo por conta própria, com validação estrita, e compila as regras em mapas hash e de correspondência pelo prefixo mais longo. As regras nunca trafegam pelo socket.
+
+**4. Nada roda por pacote.** As verificações acontecem quando uma conexão é aberta ou uma porta é vinculada, não a cada pacote. Medido numa VM de teste: cerca de **0,5 µs** por connect UDP, TCP dentro do ruído e nenhuma mudança na vazão (`docs/FIREWALL.md`).
+
+## Funciona por domínio?
+
+O motor funciona, com cuidado sobre a origem dos nomes. Uma conexão só carrega um endereço IP, então, para aplicar uma regra como "permitir só `example.com`", o firewall precisa saber a quais nomes um endereço pertence. Ele aprende isso **só com o resolvedor do sistema**: assina o monitor do systemd-resolved (ou, sem ele, lê as respostas da porta 53 dos servidores em `/etc/resolv.conf`). Ele nunca confia em respostas DNS que um app recebeu nos próprios sockets, que um app malicioso poderia forjar.
+
+[[diagram:dns]]
+
+Na VM de teste, "negar tudo exceto example.com" deixou passar `https://example.com` e negou `https://www.debian.org`, 20 de 20 vezes, mesmo com o cache do resolvedor vazio. Um app que usa seu próprio DNS sobre HTTPS obtém endereços que o firewall nunca aprendeu, então, sob uma regra dessas, eles são negados.
+
+O que **ainda não** existe: uma tela para escrever regras por domínio. O motor de regras e a API `lord.fw.addRule` aceitam domínios, curingas, redes, portas e protocolos, mas a interface hoje oferece o botão por app e as listas de restrições. Botões por destino no Monitor estão planejados.
+
+## As perguntas do leitor cético
+
+**Vale também para os apps Linux?** Sim. Esse é um dos pontos principais: Chromium, Firefox ou qualquer app aberto pelo lançador de apps tem seu próprio escopo e suas próprias regras. Os apps incluídos no LordOS e os programas iniciados pelo Terminal contam juntos como "LordOS".
+
+**Um app consegue escapar do seu escopo?** Isso foi testado. Um app Linux não consegue se inscrever em outro cgroup, porque todo arquivo `cgroup.procs` da árvore da sessão pertence ao root. Ele ainda pode pedir ao gerenciador systemd do usuário que inicie um novo processo fora da árvore (`systemd-run --user`). O LordOS fecha isso também: o `lord-netperm` anexa seus programas também ao `user@<uid>.service` de cada usuário, e qualquer processo ali fica sujeito à união mais estrita das restrições dos apps restritos daquele usuário que estão rodando. Testado com `systemd-run --user --scope`, um serviço transitório e `setsid`: todos negados.
+
+[[shot:3]]
+
+**Posso permitir uma conexão só uma vez, ou ser perguntado?** O motor de regras conhece três durações (para sempre, até o app fechar, só uma vez) e um modo "perguntar", mas o aviso de pergunta ainda não foi construído: hoje "perguntar" se comporta como silencioso. Ele foi projetado como um aviso de nova tentativa: a primeira conexão é negada, você recebe *Permitir uma vez / Sempre / Negar*, e a nova tentativa do app passa.
+
+**O que acontece se o serviço parar?** Os vínculos dele são fechados e tudo fica permitido. O desktop não depende dele. Na ISO final, o serviço estava rodando com seus sete programas anexados.
+
+**O próprio serviço é perigoso?** Ele é mantido pequeno de propósito: não executa programas, não aceita argumentos, não tem sockets de internet próprios (sua unit só permite sockets Unix e de pacote) e aceita um único tipo de mensagem. Ele usa um carregador próprio sobre a chamada de sistema `bpf()`, com os programas compilados dentro do binário; sem libbpf nem bcc.
+
+## Limites honestos
+
+- **ICMP** (ping) só é bloqueado por "sem rede". **Conexões de entrada numa porta que já está aberta**, e `listen` sem `bind`, não são conferidas: isso exigiria um gancho por pacote.
+- **A união do `user@` é grosseira:** enquanto um app restrito roda, todo processo no gerenciador systemd daquele usuário fica sujeito à união das restrições.
+- **Um escopo recém-criado** é registrado em microssegundos, mas uma conexão feita antes disso passaria pelas regras padrão.
+- **Os nomes de host ainda não aparecem no Monitor**, só IPs e países. O Monitor nunca faz DNS reverso, então nenhum endereço sai da máquina só porque você olhou para ele.
+- **As restrições que não são de rede** (câmera, microfone, tela, USB, Bluetooth, arquivos, notificações) podem ser marcadas em Ajustes, mas **ainda não são aplicadas**: só as quatro restrições de rede são. Use as permissões por app para a câmera e o microfone.
+- **O arquivo de regras pode ser editado por apps Linux sem sandbox**, já que eles rodam como você. Os apps `.lpk` instalados não o alcançam.
+
+## Leia o código
+
+- [server/src/netperm/np.bpf.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/np.bpf.c): os sete programas eBPF de cgroup
+- [server/src/netperm/netperm.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/netperm.c): o serviço root
+- [server/src/netperm/npcompile.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/npcompile.c): regras em mapas do kernel
+- [server/src/netperm/npdns.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/npdns.c): nomes vindos do resolvedor do sistema
+- [server/src/fw/rules.c](https://github.com/lordbasex/LordOS/blob/main/server/src/fw/rules.c): regras, precedência e o leitor estrito do arquivo
+- [server/src/ui/js_fw.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/js_fw.c): `lord.fw`, a API da sessão
+- [apps/monitor/Firewall.jsx](https://github.com/lordbasex/LordOS/blob/main/apps/monitor/Firewall.jsx): a seção de Ajustes
+- [server/tests/netperm_integration.sh](https://github.com/lordbasex/LordOS/blob/main/server/tests/netperm_integration.sh): o teste com o kernel, 18 de 18
+- [docs/FIREWALL.md](https://github.com/lordbasex/LordOS/blob/main/docs/FIREWALL.md) e [docs/MONITOR.md](https://github.com/lordbasex/LordOS/blob/main/docs/MONITOR.md)
diff --git a/web/content/footer.json b/web/content/footer.json
new file mode 100644
index 0000000..05e2064
--- /dev/null
+++ b/web/content/footer.json
@@ -0,0 +1,49 @@
+{
+ "columns": [
+ {
+ "title": { "en": "Product", "es": "Producto", "pt": "Produto" },
+ "links": [
+ { "label": { "en": "Features", "es": "Funciones", "pt": "Recursos" }, "href": "/#features" },
+ { "label": { "en": "Apps", "es": "Apps", "pt": "Apps" }, "href": "/apps/" },
+ { "label": { "en": "Gallery", "es": "Galería", "pt": "Galeria" }, "href": "/gallery/" },
+ { "label": { "en": "Download", "es": "Descargar", "pt": "Baixar" }, "href": "/#download" },
+ { "label": { "en": "Paper", "es": "Paper", "pt": "Paper" }, "href": "/paper/" },
+ { "label": { "en": "FAQ", "es": "Preguntas frecuentes", "pt": "Perguntas frequentes" }, "href": "/faq/" },
+ { "label": { "en": "Release notes", "es": "Notas de versión", "pt": "Notas de versão" }, "href": "https://github.com/lordbasex/LordOS/releases" }
+ ]
+ },
+ {
+ "title": { "en": "Project", "es": "Proyecto", "pt": "Projeto" },
+ "links": [
+ { "label": { "en": "About", "es": "Quiénes somos", "pt": "Sobre" }, "href": "/#about" },
+ { "label": { "en": "Support / Donate", "es": "Apoyar / Donar", "pt": "Apoiar / Doar" }, "href": "/#support" },
+ { "label": { "en": "Brand kit", "es": "Kit de marca", "pt": "Kit de marca" }, "href": "https://github.com/lordbasex/LordOS/blob/main/docs/LORDOS-BRAND.md" },
+ { "label": { "en": "GitHub", "es": "GitHub", "pt": "GitHub" }, "href": "https://github.com/lordbasex/LordOS" },
+ { "label": { "en": "Security", "es": "Seguridad", "pt": "Segurança" }, "href": "/legal/security/" }
+ ]
+ },
+ {
+ "title": { "en": "Legal", "es": "Legal", "pt": "Legal" },
+ "links": [
+ { "label": { "en": "Terms", "es": "Términos", "pt": "Termos" }, "href": "/legal/terms/" },
+ { "label": { "en": "Privacy", "es": "Privacidad", "pt": "Privacidade" }, "href": "/legal/privacy/" },
+ { "label": { "en": "Cookies", "es": "Cookies", "pt": "Cookies" }, "href": "/legal/cookies/" },
+ { "label": { "en": "Donation terms", "es": "Términos de donación", "pt": "Termos de doação" }, "href": "/legal/donations/" },
+ { "label": { "en": "Licenses", "es": "Licencias", "pt": "Licenças" }, "href": "/legal/licenses/" },
+ { "label": { "en": "Trademark", "es": "Marca", "pt": "Marca" }, "href": "/legal/trademark/" },
+ { "label": { "en": "Accessibility", "es": "Accesibilidad", "pt": "Acessibilidade" }, "href": "/legal/accessibility/" },
+ { "label": { "en": "Legal notice", "es": "Aviso legal", "pt": "Aviso legal" }, "href": "/legal/legal-notice/" }
+ ]
+ }
+ ],
+ "copyright": {
+ "en": "© 2026 IPERFEX · Pablo Miranda & Federico Pereira",
+ "es": "© 2026 IPERFEX · Pablo Miranda y Federico Pereira",
+ "pt": "© 2026 IPERFEX · Pablo Miranda e Federico Pereira"
+ },
+ "note": {
+ "en": "LordOS is free software under the MIT license.",
+ "es": "LordOS es software libre bajo la licencia MIT.",
+ "pt": "LordOS é software livre sob a licença MIT."
+ }
+}
diff --git a/web/content/legal/accessibility.en.md b/web/content/legal/accessibility.en.md
new file mode 100644
index 0000000..b4f9de4
--- /dev/null
+++ b/web/content/legal/accessibility.en.md
@@ -0,0 +1,25 @@
+We want lordos.org to be usable by everyone, including people who use a keyboard only, a screen reader, magnification or high contrast. Our goal is the Web Content Accessibility Guidelines (WCAG) 2.1, level AA. This statement covers the website; the accessibility of the LordOS distribution is described at the end.
+
+## What the website does today
+
+- **Contrast:** text and controls use strong colour contrast in both the light and the dark theme, aiming at the WCAG AA ratios.
+- **Light and dark:** the site follows your system's colour scheme, and the theme button lets you force light or dark.
+- **Keyboard:** every link, button and control can be reached and used with the keyboard. A visible focus outline shows where you are, and a "Skip to content" link is the first thing on each page. The screenshot viewer works with the arrow keys and closes with Escape.
+- **Reduced motion:** if your system asks for reduced motion, the site turns off its animations and smooth scrolling.
+- **Structure:** pages use headings, landmarks and labelled sections; images have text alternatives; each page declares its language (English, Spanish or Portuguese).
+- **Zoom and small screens:** the layout adapts to phone screens and to browser zoom.
+- **No dependence on scripts:** the content is static HTML; scripts add only conveniences such as the theme button, the copy button and the gallery filters.
+
+## Known limitations
+
+- Some screenshots show complex interfaces; their text alternatives describe them briefly rather than in full detail.
+- The paper's PDF may not be fully tagged for screen readers; the same content is available as a web page.
+- Donation pages are run by PayPal and Mercado Pago, and their accessibility is outside our control.
+
+## The LordOS distribution
+
+Accessibility in the desktop is still in progress: LordOS has a **Reduce motion** setting (Settings → Appearance), keyboard shortcuts and per-display scaling from 100 to 200 %, but a screen reader, screen zoom and a high-contrast theme are **not available yet**. They are on the roadmap.
+
+## Report a problem
+
+If something on the website is hard or impossible to use, tell us at [[CONTACT_EMAIL]]: the page, what you were trying to do, and the browser and assistive technology you use. We aim to reply within 5 business days and to fix problems in the next website update.
diff --git a/web/content/legal/accessibility.es.md b/web/content/legal/accessibility.es.md
new file mode 100644
index 0000000..5c36034
--- /dev/null
+++ b/web/content/legal/accessibility.es.md
@@ -0,0 +1,25 @@
+Queremos que lordos.org lo pueda usar todo el mundo, incluidas las personas que usan solo el teclado, un lector de pantalla, ampliación o alto contraste. Nuestro objetivo son las Pautas de Accesibilidad para el Contenido Web (WCAG) 2.1, nivel AA. Esta declaración cubre el sitio; la accesibilidad de la distribución LordOS se describe al final.
+
+## Qué hace el sitio hoy
+
+- **Contraste:** los textos y los controles usan un contraste de color fuerte en el tema claro y en el oscuro, buscando cumplir las relaciones de WCAG AA.
+- **Claro y oscuro:** el sitio sigue el esquema de colores de tu sistema, y el botón de tema te permite forzar el claro o el oscuro.
+- **Teclado:** todos los enlaces, botones y controles se pueden alcanzar y usar con el teclado. Un contorno de foco visible muestra dónde estás, y un enlace "Ir al contenido" es lo primero de cada página. El visor de capturas funciona con las flechas y se cierra con Escape.
+- **Movimiento reducido:** si tu sistema pide reducir el movimiento, el sitio desactiva sus animaciones y el desplazamiento suave.
+- **Estructura:** las páginas usan encabezados, regiones y secciones con nombre; las imágenes tienen texto alternativo; cada página declara su idioma (inglés, español o portugués).
+- **Zoom y pantallas chicas:** el diseño se adapta a pantallas de teléfono y al zoom del navegador.
+- **Sin depender de scripts:** el contenido es HTML estático; los scripts solo agregan comodidades como el botón de tema, el botón de copiar y los filtros de la galería.
+
+## Limitaciones conocidas
+
+- Algunas capturas muestran interfaces complejas; su texto alternativo las describe brevemente, no en todo detalle.
+- Puede que el PDF del paper no esté completamente etiquetado para lectores de pantalla; el mismo contenido está disponible como página web.
+- Las páginas de donación son de PayPal y Mercado Pago, y su accesibilidad no depende de nosotros.
+
+## La distribución LordOS
+
+La accesibilidad del escritorio todavía está en desarrollo: LordOS tiene el ajuste **Reducir movimiento** (Ajustes → Apariencia), atajos de teclado y escala por pantalla de 100 a 200 %, pero un lector de pantalla, el zoom de pantalla y un tema de alto contraste **todavía no están disponibles**. Están en la hoja de ruta.
+
+## Reportar un problema
+
+Si algo del sitio te resulta difícil o imposible de usar, contanos en [[CONTACT_EMAIL]]: la página, qué querías hacer, y el navegador y la tecnología de apoyo que usás. Buscamos responder dentro de 5 días hábiles y corregir los problemas en la próxima actualización del sitio.
diff --git a/web/content/legal/accessibility.pt.md b/web/content/legal/accessibility.pt.md
new file mode 100644
index 0000000..d25939c
--- /dev/null
+++ b/web/content/legal/accessibility.pt.md
@@ -0,0 +1,25 @@
+Queremos que o lordos.org possa ser usado por todos, incluindo quem usa só o teclado, um leitor de tela, ampliação ou alto contraste. A nossa meta são as Diretrizes de Acessibilidade para Conteúdo Web (WCAG) 2.1, nível AA. Esta declaração cobre o site; a acessibilidade da distribuição LordOS é descrita no final.
+
+## O que o site faz hoje
+
+- **Contraste:** textos e controles usam um contraste de cores forte nos temas claro e escuro, buscando as proporções do nível AA da WCAG.
+- **Claro e escuro:** o site segue o esquema de cores do seu sistema, e o botão de tema permite forçar o claro ou o escuro.
+- **Teclado:** todos os links, botões e controles podem ser alcançados e usados pelo teclado. Um contorno de foco visível mostra onde você está, e um link "Ir para o conteúdo" é a primeira coisa de cada página. O visualizador de capturas de tela funciona com as setas e fecha com Esc.
+- **Movimento reduzido:** se o seu sistema pedir movimento reduzido, o site desliga as animações e a rolagem suave.
+- **Estrutura:** as páginas usam títulos, regiões e seções rotuladas; as imagens têm texto alternativo; cada página declara o seu idioma (inglês, espanhol ou português).
+- **Zoom e telas pequenas:** o layout se adapta a telas de celular e ao zoom do navegador.
+- **Sem depender de scripts:** o conteúdo é HTML estático; os scripts só adicionam comodidades, como o botão de tema, o botão de copiar e os filtros da galeria.
+
+## Limitações conhecidas
+
+- Algumas capturas de tela mostram interfaces complexas; os textos alternativos as descrevem de forma breve, não em todos os detalhes.
+- O PDF do paper pode não estar totalmente marcado para leitores de tela; o mesmo conteúdo está disponível como página web.
+- As páginas de doação são do PayPal e do Mercado Pago, e a acessibilidade delas está fora do nosso controle.
+
+## A distribuição LordOS
+
+A acessibilidade no desktop ainda está em andamento: o LordOS tem a opção **Reduzir movimento** (Ajustes → Aparência), atalhos de teclado e escala por tela de 100 a 200 %, mas um leitor de tela, o zoom de tela e um tema de alto contraste **ainda não estão disponíveis**. Eles estão no roadmap.
+
+## Relatar um problema
+
+Se algo no site for difícil ou impossível de usar, conte para nós em [[CONTACT_EMAIL]]: a página, o que você estava tentando fazer, e o navegador e a tecnologia assistiva que você usa. Procuramos responder em até 5 dias úteis e corrigir os problemas na próxima atualização do site.
diff --git a/web/content/legal/cookies.en.md b/web/content/legal/cookies.en.md
new file mode 100644
index 0000000..ed9fe92
--- /dev/null
+++ b/web/content/legal/cookies.en.md
@@ -0,0 +1,26 @@
+## No cookies
+
+lordos.org sets **no cookies**: no analytics, advertising, tracking or session cookies, and none from third parties. That's why the website shows no cookie banner.
+
+## What the website keeps in your browser
+
+Two small preferences are saved in your browser's `localStorage`, on your device only:
+
+| Key | Value | Purpose |
+|---|---|---|
+| `lordos-theme` | `light` or `dark` | remembers the theme you chose with the theme button; with automatic, nothing is saved and the site follows your system |
+| `lordos-lang-seen` | `1` | shows the suggestion to read the site in your language only once |
+
+They are never sent to a server, they don't identify you, and they are not shared with anyone. If your browser blocks storage, the website still works: it just forgets your choices.
+
+## How to remove them
+
+Delete the site data for lordos.org in your browser's settings (usually under Privacy → Site data or Cookies and site data). Private windows remove them when you close the window.
+
+## Other sites
+
+When you follow a link to GitHub, PayPal, Mercado Pago or any other site, that site's own cookie policy applies.
+
+## More
+
+See the [Privacy policy](/legal/privacy/). Questions: [[CONTACT_EMAIL]].
diff --git a/web/content/legal/cookies.es.md b/web/content/legal/cookies.es.md
new file mode 100644
index 0000000..584c1e5
--- /dev/null
+++ b/web/content/legal/cookies.es.md
@@ -0,0 +1,26 @@
+## Sin cookies
+
+lordos.org **no usa cookies**: ni de estadísticas, ni de publicidad, ni de rastreo, ni de sesión, y tampoco de terceros. Por eso el sitio no muestra ningún aviso de cookies.
+
+## Qué guarda el sitio en tu navegador
+
+Se guardan dos pequeñas preferencias en el `localStorage` de tu navegador, solo en tu dispositivo:
+
+| Clave | Valor | Para qué |
+|---|---|---|
+| `lordos-theme` | `light` o `dark` | recuerda el tema que elegiste con el botón de tema; con el automático no se guarda nada y el sitio sigue a tu sistema |
+| `lordos-lang-seen` | `1` | muestra una sola vez la sugerencia de leer el sitio en tu idioma |
+
+Nunca se envían a un servidor, no te identifican y no se comparten con nadie. Si tu navegador bloquea el almacenamiento, el sitio funciona igual: simplemente se olvida de lo que elegiste.
+
+## Cómo borrarlas
+
+Borrá los datos del sitio lordos.org desde la configuración de tu navegador (normalmente en Privacidad → Datos de sitios, o Cookies y datos de sitios). Las ventanas privadas los borran al cerrarse.
+
+## Otros sitios
+
+Cuando seguís un enlace a GitHub, PayPal, Mercado Pago o cualquier otro sitio, se aplica la política de cookies de ese sitio.
+
+## Más información
+
+Mirá la [Política de privacidad](/legal/privacy/). Consultas: [[CONTACT_EMAIL]].
diff --git a/web/content/legal/cookies.pt.md b/web/content/legal/cookies.pt.md
new file mode 100644
index 0000000..e11351b
--- /dev/null
+++ b/web/content/legal/cookies.pt.md
@@ -0,0 +1,26 @@
+## Sem cookies
+
+O lordos.org **não define cookies**: nenhum cookie de análise, publicidade, rastreamento ou sessão, e nenhum de terceiros. Por isso o site não mostra um aviso de cookies.
+
+## O que o site guarda no seu navegador
+
+Duas pequenas preferências ficam salvas no `localStorage` do seu navegador, apenas no seu dispositivo:
+
+| Chave | Valor | Finalidade |
+|---|---|---|
+| `lordos-theme` | `light` ou `dark` | lembra o tema que você escolheu com o botão de tema; no automático nada é salvo e o site segue o seu sistema |
+| `lordos-lang-seen` | `1` | mostra só uma vez a sugestão de ler o site no seu idioma |
+
+Elas nunca são enviadas a um servidor, não identificam você e não são compartilhadas com ninguém. Se o seu navegador bloquear o armazenamento, o site continua funcionando: só esquece as suas escolhas.
+
+## Como apagá-las
+
+Apague os dados do site lordos.org nas configurações do navegador (geralmente em Privacidade → Dados de sites ou Cookies e dados de sites). As janelas anônimas os apagam quando você fecha a janela.
+
+## Outros sites
+
+Quando você segue um link para o GitHub, o PayPal, o Mercado Pago ou qualquer outro site, vale a política de cookies desse site.
+
+## Mais
+
+Veja a [Política de privacidade](/legal/privacy/). Dúvidas: [[CONTACT_EMAIL]].
diff --git a/web/content/legal/donations.en.md b/web/content/legal/donations.en.md
new file mode 100644
index 0000000..b495608
--- /dev/null
+++ b/web/content/legal/donations.en.md
@@ -0,0 +1,35 @@
+LordOS is free and will stay free. Donations help the IPERFEX group keep building it: development time, testing on real hardware and hosting.
+
+## A donation is voluntary
+
+Donating is entirely optional. Everything on lordos.org and in LordOS is available whether you donate or not.
+
+## Not a purchase
+
+A donation is a gift, not a payment for goods or services. In exchange for it you receive no product, license, support, priority, features, influence over the roadmap, or any other benefit. We don't promise any specific result from the money we receive.
+
+## Payment processors
+
+Donations are processed entirely by third parties:
+
+- **PayPal** (to `[email protected]`), under [PayPal's terms](https://www.paypal.com/legalhub/home) and privacy statement;
+- **Mercado Pago** (`link.mercadopago.com.ar/lordos`), under [Mercado Pago's terms](https://www.mercadopago.com.ar/ayuda/terminos-y-politicas_194);
+- **Binance**, when it becomes available, under Binance's terms.
+
+We never see or store your card or bank details. The processor may charge fees, apply currency conversion, or refuse or reverse a payment under its own rules.
+
+## Refunds
+
+Donations are **non-refundable**, except where the law requires otherwise. If you donated by mistake (for example, a wrong amount or a duplicated payment), write to [[CONTACT_EMAIL]] within 30 days with the date, the amount and the processor, and we will look at it in good faith.
+
+## Taxes
+
+Donations to LordOS are **not tax-deductible**. The IPERFEX group is not a registered charity or non-profit organization, and we can't issue tax receipts for donations. You are responsible for any taxes that apply to you.
+
+## Who receives them
+
+Donations are received by [[LEGAL_ENTITY]], on behalf of the IPERFEX group.
+
+## Contact
+
+Questions about donations: [[CONTACT_EMAIL]].
diff --git a/web/content/legal/donations.es.md b/web/content/legal/donations.es.md
new file mode 100644
index 0000000..3d5cb8a
--- /dev/null
+++ b/web/content/legal/donations.es.md
@@ -0,0 +1,35 @@
+LordOS es gratis y va a seguir siéndolo. Las donaciones ayudan al grupo IPERFEX a seguir construyéndolo: tiempo de desarrollo, pruebas en hardware real y alojamiento.
+
+## Donar es voluntario
+
+Donar es totalmente opcional. Todo lo que hay en lordos.org y en LordOS está disponible dones o no.
+
+## No es una compra
+
+Una donación es un regalo, no un pago por bienes o servicios. A cambio no recibís ningún producto, licencia, soporte, prioridad, función, influencia sobre la hoja de ruta ni ningún otro beneficio. No prometemos ningún resultado específico con el dinero que recibimos.
+
+## Procesadores de pago
+
+Las donaciones las procesan por completo terceros:
+
+- **PayPal** (a `[email protected]`), según los [términos de PayPal](https://www.paypal.com/legalhub/home) y su declaración de privacidad;
+- **Mercado Pago** (`link.mercadopago.com.ar/lordos`), según los [términos de Mercado Pago](https://www.mercadopago.com.ar/ayuda/terminos-y-politicas_194);
+- **Binance**, cuando esté disponible, según los términos de Binance.
+
+Nunca vemos ni guardamos los datos de tu tarjeta o de tu banco. El procesador puede cobrar comisiones, aplicar conversión de moneda, o rechazar o revertir un pago según sus propias reglas.
+
+## Reembolsos
+
+Las donaciones **no son reembolsables**, salvo cuando la ley disponga otra cosa. Si donaste por error (por ejemplo, un monto equivocado o un pago duplicado), escribinos a [[CONTACT_EMAIL]] dentro de los 30 días con la fecha, el monto y el procesador, y lo vamos a revisar de buena fe.
+
+## Impuestos
+
+Las donaciones a LordOS **no son deducibles de impuestos**. El grupo IPERFEX no es una entidad de bien público ni una organización sin fines de lucro registrada, y no podemos emitir comprobantes fiscales por donaciones. Sos responsable de los impuestos que te correspondan.
+
+## Quién las recibe
+
+Las donaciones las recibe [[LEGAL_ENTITY]], en nombre del grupo IPERFEX.
+
+## Contacto
+
+Consultas sobre donaciones: [[CONTACT_EMAIL]].
diff --git a/web/content/legal/donations.pt.md b/web/content/legal/donations.pt.md
new file mode 100644
index 0000000..7f114f5
--- /dev/null
+++ b/web/content/legal/donations.pt.md
@@ -0,0 +1,35 @@
+O LordOS é gratuito e vai continuar gratuito. As doações ajudam o grupo IPERFEX a continuar desenvolvendo: tempo de desenvolvimento, testes em hardware real e hospedagem.
+
+## Uma doação é voluntária
+
+Doar é totalmente opcional. Tudo no lordos.org e no LordOS está disponível, quer você doe ou não.
+
+## Não é uma compra
+
+Uma doação é um presente, não um pagamento por bens ou serviços. Em troca dela você não recebe nenhum produto, licença, suporte, prioridade, recurso, influência sobre o roadmap nem qualquer outro benefício. Não prometemos nenhum resultado específico com o dinheiro recebido.
+
+## Processadores de pagamento
+
+As doações são processadas inteiramente por terceiros:
+
+- **PayPal** (para `[email protected]`), conforme os [termos do PayPal](https://www.paypal.com/legalhub/home) e a declaração de privacidade dele;
+- **Mercado Pago** (`link.mercadopago.com.ar/lordos`), conforme os [termos do Mercado Pago](https://www.mercadopago.com.ar/ayuda/terminos-y-politicas_194);
+- **Binance**, quando estiver disponível, conforme os termos da Binance.
+
+Nunca vemos nem guardamos os dados do seu cartão ou da sua conta bancária. O processador pode cobrar tarifas, aplicar conversão de moeda ou recusar ou estornar um pagamento segundo as regras dele.
+
+## Reembolsos
+
+As doações **não são reembolsáveis**, exceto quando a lei exigir o contrário. Se você doou por engano (por exemplo, um valor errado ou um pagamento duplicado), escreva para [[CONTACT_EMAIL]] em até 30 dias com a data, o valor e o processador, e analisaremos o caso de boa-fé.
+
+## Impostos
+
+As doações ao LordOS **não são dedutíveis de impostos**. O grupo IPERFEX não é uma entidade beneficente nem uma organização sem fins lucrativos registrada, e não podemos emitir recibos fiscais de doações. Você é responsável pelos impostos que se aplicarem a você.
+
+## Quem as recebe
+
+As doações são recebidas por [[LEGAL_ENTITY]], em nome do grupo IPERFEX.
+
+## Contato
+
+Dúvidas sobre doações: [[CONTACT_EMAIL]].
diff --git a/web/content/legal/legal-notice.en.md b/web/content/legal/legal-notice.en.md
new file mode 100644
index 0000000..0fe73c3
--- /dev/null
+++ b/web/content/legal/legal-notice.en.md
@@ -0,0 +1,27 @@
+## Who runs this website
+
+lordos.org is the website of **LordOS**, a free Debian-based GNU/Linux distribution with its own desktop environment.
+
+- **Project:** LordOS, by the IPERFEX group
+- **Authors:** Pablo Miranda and Federico Pereira
+- **Responsible entity:** [[LEGAL_ENTITY]]
+- **Address:** [[ADDRESS]]
+- **Country:** Argentina
+- **Email:** [[CONTACT_EMAIL]]
+- **Security reports:** [[SECURITY_EMAIL]] (see the [Security policy](/legal/security/))
+
+## Hosting
+
+The website is a set of static pages hosted on Amazon Web Services (Amazon S3 and Amazon CloudFront). The release files are hosted on GitHub Releases.
+
+## Content and liability
+
+We write the content of this website carefully, but we can't guarantee that it is complete, correct or up to date. The software is provided without warranty, as explained in the [Terms of use](/legal/terms/). We are not responsible for the content of external sites we link to.
+
+## Copyright
+
+The text, images and code of this website are part of the LordOS project and, unless stated otherwise, are released under the [MIT license](https://github.com/lordbasex/LordOS/blob/main/LICENSE). The LordOS name, the crown logo and Lumo are covered by the [Trademark and brand policy](/legal/trademark/).
+
+## Other legal pages
+
+[Terms of use](/legal/terms/) · [Privacy policy](/legal/privacy/) · [Cookie notice](/legal/cookies/) · [Donation terms](/legal/donations/) · [Licenses](/legal/licenses/) · [Trademark and brand policy](/legal/trademark/) · [Security policy](/legal/security/) · [Accessibility](/legal/accessibility/)
diff --git a/web/content/legal/legal-notice.es.md b/web/content/legal/legal-notice.es.md
new file mode 100644
index 0000000..2ad5c89
--- /dev/null
+++ b/web/content/legal/legal-notice.es.md
@@ -0,0 +1,27 @@
+## Quién administra este sitio
+
+lordos.org es el sitio de **LordOS**, una distribución GNU/Linux libre basada en Debian, con un entorno de escritorio propio.
+
+- **Proyecto:** LordOS, del grupo IPERFEX
+- **Autores:** Pablo Miranda y Federico Pereira
+- **Responsable:** [[LEGAL_ENTITY]]
+- **Domicilio:** [[ADDRESS]]
+- **País:** Argentina
+- **Email:** [[CONTACT_EMAIL]]
+- **Reportes de seguridad:** [[SECURITY_EMAIL]] (mirá la [Política de seguridad](/legal/security/))
+
+## Alojamiento
+
+El sitio es un conjunto de páginas estáticas alojadas en Amazon Web Services (Amazon S3 y Amazon CloudFront). Los archivos de cada versión están alojados en GitHub Releases.
+
+## Contenido y responsabilidad
+
+Escribimos el contenido de este sitio con cuidado, pero no podemos garantizar que esté completo, sea correcto o esté actualizado. El software se ofrece sin garantía, como se explica en los [Términos de uso](/legal/terms/). No somos responsables del contenido de los sitios externos a los que enlazamos.
+
+## Derechos de autor
+
+Los textos, las imágenes y el código de este sitio son parte del proyecto LordOS y, salvo que se indique otra cosa, se publican bajo la [licencia MIT](https://github.com/lordbasex/LordOS/blob/main/LICENSE). El nombre LordOS, el logo de la corona y Lumo están cubiertos por la [Política de marca](/legal/trademark/).
+
+## Otras páginas legales
+
+[Términos de uso](/legal/terms/) · [Política de privacidad](/legal/privacy/) · [Aviso de cookies](/legal/cookies/) · [Términos de las donaciones](/legal/donations/) · [Licencias](/legal/licenses/) · [Política de marca](/legal/trademark/) · [Política de seguridad](/legal/security/) · [Accesibilidad](/legal/accessibility/)
diff --git a/web/content/legal/legal-notice.pt.md b/web/content/legal/legal-notice.pt.md
new file mode 100644
index 0000000..f05df4b
--- /dev/null
+++ b/web/content/legal/legal-notice.pt.md
@@ -0,0 +1,27 @@
+## Quem mantém este site
+
+lordos.org é o site do **LordOS**, uma distribuição GNU/Linux livre baseada no Debian, com ambiente de desktop próprio.
+
+- **Projeto:** LordOS, do grupo IPERFEX
+- **Autores:** Pablo Miranda e Federico Pereira
+- **Entidade responsável:** [[LEGAL_ENTITY]]
+- **Endereço:** [[ADDRESS]]
+- **País:** Argentina
+- **E-mail:** [[CONTACT_EMAIL]]
+- **Relatos de segurança:** [[SECURITY_EMAIL]] (veja a [Política de segurança](/legal/security/))
+
+## Hospedagem
+
+O site é um conjunto de páginas estáticas hospedado na Amazon Web Services (Amazon S3 e Amazon CloudFront). Os arquivos de release ficam hospedados no GitHub Releases.
+
+## Conteúdo e responsabilidade
+
+Escrevemos o conteúdo deste site com cuidado, mas não podemos garantir que ele esteja completo, correto ou atualizado. O software é fornecido sem garantia, como explicam os [Termos de uso](/legal/terms/). Não somos responsáveis pelo conteúdo dos sites externos para os quais apontamos links.
+
+## Direitos autorais
+
+Os textos, as imagens e o código deste site fazem parte do projeto LordOS e, salvo indicação em contrário, são publicados sob a [licença MIT](https://github.com/lordbasex/LordOS/blob/main/LICENSE). O nome LordOS, o logo da coroa e o Lumo seguem a [Política de marca](/legal/trademark/).
+
+## Outras páginas legais
+
+[Termos de uso](/legal/terms/) · [Política de privacidade](/legal/privacy/) · [Aviso de cookies](/legal/cookies/) · [Termos das doações](/legal/donations/) · [Licenças](/legal/licenses/) · [Política de marca](/legal/trademark/) · [Política de segurança](/legal/security/) · [Acessibilidade](/legal/accessibility/)
diff --git a/web/content/legal/licenses.en.md b/web/content/legal/licenses.en.md
new file mode 100644
index 0000000..c8c3ea1
--- /dev/null
+++ b/web/content/legal/licenses.en.md
@@ -0,0 +1,47 @@
+## LordOS: the MIT license
+
+LordOS's own code (the desktop environment, the display server and Wayland compositor, the native apps, the SDK, the themes, the tools and this website) is released under the **MIT license**:
+
+> Copyright (c) 2026 Federico Pereira and the LordOS contributors.
+>
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files, to deal in the software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense and/or sell copies of it, subject to including the copyright notice and the permission notice in all copies or substantial portions of the software. The software is provided "as is", without warranty of any kind.
+
+This is a summary; the [full text of the license](https://github.com/lordbasex/LordOS/blob/main/LICENSE) is the one that applies.
+
+The MIT license covers the code. It doesn't grant rights to the LordOS name, the crown logo or Lumo, the mascot: see the [Trademark and brand policy](/legal/trademark/).
+
+## Third-party components bundled with LordOS
+
+These components live in the LordOS repository (`third_party/` and `assets/`) and keep their own licenses. The complete list is in [THIRD_PARTY.md](https://github.com/lordbasex/LordOS/blob/main/THIRD_PARTY.md).
+
+| Component | Used for | License |
+|---|---|---|
+| QuickJS | JavaScript engine for the interface | MIT |
+| stb_image, stb_image_write, stb_truetype | image decoding and encoding, font rasterization | MIT or public domain |
+| Monocypher 4 | cryptography for the password vault and keyring | CC0-1.0 or BSD-2-Clause |
+| EFF large wordlist | passphrase generator | CC BY 3.0 |
+| SecLists common passwords | weak-password check | MIT |
+| React, react-reconciler, scheduler | the interface's component model (bundled at build time) | MIT |
+
+## Fonts and data
+
+| Data | Used for | License |
+|---|---|---|
+| Plus Jakarta Sans 2.7.1 | the LordOS wordmark, in the interface, the logo files and this website | SIL Open Font License 1.1 ([license text](/licenses/PlusJakartaSans-OFL.txt)) |
+| Inter | interface text | SIL Open Font License 1.1 |
+| JetBrains Mono | terminal and code text | SIL Open Font License 1.1 |
+| DB-IP Lite Country | offline IP-to-country lookup in Monitor | CC BY 4.0, IP geolocation by [DB-IP](https://db-ip.com) |
+| Natural Earth | the world map in Monitor | public domain |
+| Unicode Character Database and CLDR | text layout, bidirectional text, emoji names | Unicode License v3 |
+
+## Debian packages
+
+LordOS is built on Debian. The base system, the Linux kernel, Mesa, PipeWire, CUPS, BlueZ, the firmware, the fonts, the preinstalled browsers and every package installed from the Store are Debian packages (and, on the Raspberry Pi, the kernel and firmware come from the Raspberry Pi archive). Each one is distributed under its own license, mostly free software licenses such as the GPL, LGPL, MIT, BSD and Apache licenses; some firmware is non-free and redistributable.
+
+On an installed system, every package's copyright and license is in `/usr/share/doc/<package>/copyright`. The source code of Debian packages is available from Debian ([sources.debian.org](https://sources.debian.org)).
+
+LordOS links some system libraries dynamically: libwayland and libxkbcommon (MIT), Mesa (MIT), OpenSSL 3 (Apache-2.0), libcrypt (LGPL-2.1+), Poppler, cairo, FreeType and fontconfig (GPL-2.0-or-later, LGPL, FTL), libarchive (BSD-2-Clause) and FFmpeg and libva (LGPL-2.1+; Debian's FFmpeg build is GPL-2.0-or-later). The `lord-doc` and `lord-media` helpers link Poppler and Debian's FFmpeg, so those two binaries, as distributed, are covered by the GPL; the MIT-licensed LordOS source they are built from is compatible with it.
+
+## Source code
+
+The source code of LordOS is in [github.com/lordbasex/LordOS](https://github.com/lordbasex/LordOS). If you need the corresponding source of a GPL component we distribute and can't find it, write to [[CONTACT_EMAIL]].
diff --git a/web/content/legal/licenses.es.md b/web/content/legal/licenses.es.md
new file mode 100644
index 0000000..141bd59
--- /dev/null
+++ b/web/content/legal/licenses.es.md
@@ -0,0 +1,47 @@
+## LordOS: la licencia MIT
+
+El código propio de LordOS (el entorno de escritorio, el servidor gráfico y compositor Wayland, las apps nativas, el SDK, los temas, las herramientas y este sitio) se publica bajo la **licencia MIT**:
+
+> Copyright (c) 2026 Federico Pereira y los colaboradores de LordOS.
+>
+> Se concede permiso, sin cargo, a cualquier persona que obtenga una copia de este software y de los archivos de documentación asociados, para usar el software sin restricciones, incluidos sin limitación los derechos de usar, copiar, modificar, fusionar, publicar, distribuir, sublicenciar y/o vender copias, con la condición de incluir el aviso de copyright y este aviso de permiso en todas las copias o partes sustanciales del software. El software se ofrece "tal cual", sin garantía de ningún tipo.
+
+Esto es un resumen; el que se aplica es el [texto completo de la licencia](https://github.com/lordbasex/LordOS/blob/main/LICENSE) (en inglés).
+
+La licencia MIT cubre el código. No da derechos sobre el nombre LordOS, el logo de la corona ni Lumo, la mascota: mirá la [Política de marca](/legal/trademark/).
+
+## Componentes de terceros incluidos en LordOS
+
+Estos componentes están en el repositorio de LordOS (`third_party/` y `assets/`) y mantienen sus propias licencias. La lista completa está en [THIRD_PARTY.md](https://github.com/lordbasex/LordOS/blob/main/THIRD_PARTY.md).
+
+| Componente | Para qué se usa | Licencia |
+|---|---|---|
+| QuickJS | motor de JavaScript de la interfaz | MIT |
+| stb_image, stb_image_write, stb_truetype | decodificación y codificación de imágenes, rasterizado de fuentes | MIT o dominio público |
+| Monocypher 4 | criptografía de la bóveda de contraseñas y del llavero | CC0-1.0 o BSD-2-Clause |
+| EFF large wordlist | generador de frases de contraseña | CC BY 3.0 |
+| Contraseñas comunes de SecLists | comprobación de contraseñas débiles | MIT |
+| React, react-reconciler, scheduler | el modelo de componentes de la interfaz (incluido al compilar) | MIT |
+
+## Fuentes y datos
+
+| Datos | Para qué se usan | Licencia |
+|---|---|---|
+| Plus Jakarta Sans 2.7.1 | el logotipo de LordOS, en la interfaz, en los archivos del logo y en este sitio | SIL Open Font License 1.1 ([texto de la licencia](/licenses/PlusJakartaSans-OFL.txt)) |
+| Inter | texto de la interfaz | SIL Open Font License 1.1 |
+| JetBrains Mono | texto de la terminal y del código | SIL Open Font License 1.1 |
+| DB-IP Lite Country | búsqueda de IP a país sin conexión en Monitor | CC BY 4.0, geolocalización IP de [DB-IP](https://db-ip.com) |
+| Natural Earth | el mapa del mundo de Monitor | dominio público |
+| Unicode Character Database y CLDR | composición de texto, texto bidireccional, nombres de emoji | Unicode License v3 |
+
+## Paquetes de Debian
+
+LordOS está construido sobre Debian. El sistema base, el kernel Linux, Mesa, PipeWire, CUPS, BlueZ, el firmware, las fuentes, los navegadores preinstalados y todos los paquetes que se instalan desde la Tienda son paquetes de Debian (y, en la Raspberry Pi, el kernel y el firmware vienen del repositorio de Raspberry Pi). Cada uno se distribuye bajo su propia licencia, en su mayoría licencias de software libre como la GPL, la LGPL, la MIT, la BSD y la Apache; parte del firmware es no libre y redistribuible.
+
+En un sistema instalado, el copyright y la licencia de cada paquete están en `/usr/share/doc/<package>/copyright`. El código fuente de los paquetes de Debian está disponible en Debian ([sources.debian.org](https://sources.debian.org)).
+
+LordOS enlaza dinámicamente algunas bibliotecas del sistema: libwayland y libxkbcommon (MIT), Mesa (MIT), OpenSSL 3 (Apache-2.0), libcrypt (LGPL-2.1+), Poppler, cairo, FreeType y fontconfig (GPL-2.0-or-later, LGPL, FTL), libarchive (BSD-2-Clause) y FFmpeg y libva (LGPL-2.1+; la compilación de FFmpeg de Debian es GPL-2.0-or-later). Los procesos auxiliares `lord-doc` y `lord-media` enlazan Poppler y el FFmpeg de Debian, así que esos dos binarios, tal como se distribuyen, quedan cubiertos por la GPL; el código fuente de LordOS con licencia MIT del que se compilan es compatible con ella.
+
+## Código fuente
+
+El código fuente de LordOS está en [github.com/lordbasex/LordOS](https://github.com/lordbasex/LordOS). Si necesitás el código fuente correspondiente de un componente GPL que distribuimos y no lo encontrás, escribinos a [[CONTACT_EMAIL]].
diff --git a/web/content/legal/licenses.pt.md b/web/content/legal/licenses.pt.md
new file mode 100644
index 0000000..cec09b2
--- /dev/null
+++ b/web/content/legal/licenses.pt.md
@@ -0,0 +1,47 @@
+## LordOS: a licença MIT
+
+O código próprio do LordOS (o ambiente de desktop, o servidor gráfico e compositor Wayland, os apps nativos, o SDK, os temas, as ferramentas e este site) é publicado sob a **licença MIT**:
+
+> Copyright (c) 2026 Federico Pereira e os colaboradores do LordOS.
+>
+> É concedida permissão, gratuitamente, a qualquer pessoa que obtenha uma cópia deste software e dos arquivos de documentação associados, para lidar com o software sem restrições, incluindo, sem limitação, os direitos de usar, copiar, modificar, mesclar, publicar, distribuir, sublicenciar e/ou vender cópias dele, desde que o aviso de copyright e este aviso de permissão sejam incluídos em todas as cópias ou partes substanciais do software. O software é fornecido "no estado em que se encontra", sem garantia de nenhum tipo.
+
+Isto é um resumo; o que vale é o [texto completo da licença](https://github.com/lordbasex/LordOS/blob/main/LICENSE), em inglês.
+
+A licença MIT cobre o código. Ela não concede direitos sobre o nome LordOS, o logo da coroa nem sobre Lumo, o mascote: veja a [Política de marca](/legal/trademark/).
+
+## Componentes de terceiros incluídos no LordOS
+
+Estes componentes ficam no repositório do LordOS (`third_party/` e `assets/`) e mantêm as suas próprias licenças. A lista completa está em [THIRD_PARTY.md](https://github.com/lordbasex/LordOS/blob/main/THIRD_PARTY.md).
+
+| Componente | Usado para | Licença |
+|---|---|---|
+| QuickJS | motor JavaScript da interface | MIT |
+| stb_image, stb_image_write, stb_truetype | decodificação e codificação de imagens, rasterização de fontes | MIT ou domínio público |
+| Monocypher 4 | criptografia do cofre de senhas e do chaveiro | CC0-1.0 ou BSD-2-Clause |
+| Lista de palavras grande da EFF | gerador de frases-senha | CC BY 3.0 |
+| Senhas comuns do SecLists | verificação de senhas fracas | MIT |
+| React, react-reconciler, scheduler | o modelo de componentes da interface (incluído na compilação) | MIT |
+
+## Fontes e dados
+
+| Dados | Usado para | Licença |
+|---|---|---|
+| Plus Jakarta Sans 2.7.1 | o logotipo LordOS, na interface, nos arquivos do logo e neste site | SIL Open Font License 1.1 ([texto da licença](/licenses/PlusJakartaSans-OFL.txt)) |
+| Inter | textos da interface | SIL Open Font License 1.1 |
+| JetBrains Mono | textos do terminal e de código | SIL Open Font License 1.1 |
+| DB-IP Lite Country | consulta offline de IP para país no Monitor | CC BY 4.0, geolocalização de IP por [DB-IP](https://db-ip.com) |
+| Natural Earth | o mapa-múndi do Monitor | domínio público |
+| Unicode Character Database e CLDR | layout de texto, texto bidirecional, nomes de emoji | Unicode License v3 |
+
+## Pacotes do Debian
+
+O LordOS é construído sobre o Debian. O sistema base, o kernel Linux, o Mesa, o PipeWire, o CUPS, o BlueZ, os firmwares, as fontes, os navegadores pré-instalados e todos os pacotes instalados pela Loja são pacotes do Debian (e, no Raspberry Pi, o kernel e o firmware vêm do repositório do Raspberry Pi). Cada um é distribuído sob a sua própria licença, em geral licenças de software livre como GPL, LGPL, MIT, BSD e Apache; alguns firmwares não são livres, mas podem ser redistribuídos.
+
+Em um sistema instalado, o copyright e a licença de cada pacote estão em `/usr/share/doc/<pacote>/copyright`. O código-fonte dos pacotes do Debian está disponível no próprio Debian ([sources.debian.org](https://sources.debian.org)).
+
+O LordOS se vincula dinamicamente a algumas bibliotecas do sistema: libwayland e libxkbcommon (MIT), Mesa (MIT), OpenSSL 3 (Apache-2.0), libcrypt (LGPL-2.1+), Poppler, cairo, FreeType e fontconfig (GPL-2.0-or-later, LGPL, FTL), libarchive (BSD-2-Clause) e FFmpeg e libva (LGPL-2.1+; a compilação do FFmpeg do Debian é GPL-2.0-or-later). Os auxiliares `lord-doc` e `lord-media` se vinculam ao Poppler e ao FFmpeg do Debian, por isso esses dois binários, como distribuídos, ficam cobertos pela GPL; o código-fonte do LordOS sob a licença MIT, a partir do qual eles são compilados, é compatível com ela.
+
+## Código-fonte
+
+O código-fonte do LordOS está em [github.com/lordbasex/LordOS](https://github.com/lordbasex/LordOS). Se você precisar do código-fonte correspondente de um componente GPL que distribuímos e não o encontrar, escreva para [[CONTACT_EMAIL]].
diff --git a/web/content/legal/pages.json b/web/content/legal/pages.json
new file mode 100644
index 0000000..6983f3f
--- /dev/null
+++ b/web/content/legal/pages.json
@@ -0,0 +1,14 @@
+{
+ "updated": "2026-10-18",
+ "pages": [
+ { "slug": "terms", "title": { "en": "Terms of use", "es": "Términos de uso", "pt": "Termos de uso" }, "updated": "2026-10-18" },
+ { "slug": "privacy", "title": { "en": "Privacy policy", "es": "Política de privacidad", "pt": "Política de privacidade" }, "updated": "2026-10-18" },
+ { "slug": "cookies", "title": { "en": "Cookie notice", "es": "Aviso de cookies", "pt": "Aviso de cookies" }, "updated": "2026-10-18" },
+ { "slug": "donations", "title": { "en": "Donation terms", "es": "Términos de las donaciones", "pt": "Termos das doações" }, "updated": "2026-10-18" },
+ { "slug": "licenses", "title": { "en": "Licenses and open-source notices", "es": "Licencias y avisos de código abierto", "pt": "Licenças e avisos de código aberto" }, "updated": "2026-10-18" },
+ { "slug": "trademark", "title": { "en": "Trademark and brand policy", "es": "Política de marca", "pt": "Política de marca" }, "updated": "2026-10-18" },
+ { "slug": "security", "title": { "en": "Security policy", "es": "Política de seguridad", "pt": "Política de segurança" }, "updated": "2026-10-18" },
+ { "slug": "legal-notice", "title": { "en": "Legal notice", "es": "Aviso legal", "pt": "Aviso legal" }, "updated": "2026-10-18" },
+ { "slug": "accessibility", "title": { "en": "Accessibility statement", "es": "Declaración de accesibilidad", "pt": "Declaração de acessibilidade" }, "updated": "2026-10-18" }
+ ]
+}
diff --git a/web/content/legal/privacy.en.md b/web/content/legal/privacy.en.md
new file mode 100644
index 0000000..2931f62
--- /dev/null
+++ b/web/content/legal/privacy.en.md
@@ -0,0 +1,85 @@
+LordOS has no accounts, no advertising and no tracking, on the website or in the distribution. Nobody sells, shares or keeps your data, because we never collect it. This policy has two parts: the **lordos.org website**, and the **LordOS distribution** you install on your computer.
+
+## Part 1: the website
+
+### What your browser keeps
+
+The website is a set of static pages. It sets **no cookies** and keeps only two values in your browser's `localStorage`, on your device:
+
+| Key | What it holds | Why |
+|---|---|---|
+| `lordos-theme` | `light` or `dark` (nothing when you use automatic) | to show the theme you chose |
+| `lordos-lang-seen` | `1` | so the "this page is also in your language" suggestion appears only once |
+
+They never leave your browser and we can't read them. Clear them at any time from your browser's site data settings. See the [Cookie notice](/legal/cookies/).
+
+### No analytics, no ads, no third-party code
+
+The website loads no analytics, no advertising, no social media widgets and no fonts or scripts from other servers: everything it needs is served from lordos.org.
+
+### Server logs
+
+The website is hosted on Amazon Web Services (S3 and CloudFront). As with any website, your browser sends your IP address and the usual request data (the page asked for, the time, the browser's user agent) to deliver the page. Standard CDN request logs may be kept by our hosting provider for security, retained for a limited time. We don't use them to identify or profile visitors.
+
+### Downloads on GitHub
+
+The ISO image, the Raspberry Pi image, the `.deb` package and their signatures are hosted on GitHub Releases. When you download them, or when the Debian installer script fetches them, GitHub receives your request under [GitHub's privacy statement](https://docs.github.com/en/site-policy/privacy-policies/github-general-privacy-statement).
+
+### Donations
+
+Donation buttons take you to PayPal or Mercado Pago (and, later, Binance). The payment happens entirely on their sites: we never see or store your card or account details. The processor tells us the amount, the date and the name or email you gave it, which we keep only for our accounting. Their own policies apply: [PayPal](https://www.paypal.com/myaccount/privacy/privacyhub), [Mercado Pago](https://www.mercadopago.com.ar/privacidad). See the [Donation terms](/legal/donations/).
+
+### Email
+
+If you write to us, we keep your message and address only to answer you and to follow up on the matter.
+
+## Part 2: the LordOS distribution
+
+### No telemetry
+
+LordOS sends **no telemetry**: no usage statistics, no crash reports, no device identifiers, no "phone home" checks and no account sign-in. Nothing about you or your computer is sent to us.
+
+### What LordOS connects to by default
+
+These are the only network connections a fresh LordOS installation makes without you asking for something:
+
+| Connection | When | Why | How to turn it off |
+|---|---|---|---|
+| **DHCP and DNS** on your local network | when a network cable or Wi-Fi network is connected | to get an address and resolve names; DNS goes to the servers your network gives you or that you set | disconnect, or set a manual address and DNS in Settings → Network |
+| **Network time (NTP)** through `systemd-timesyncd`, to Debian's public NTP pool | when the computer is online | to keep the clock right | Settings → Date & Time → automatic time off |
+| **mDNS** (`avahi-daemon`, on PCs; the Raspberry Pi image does not include it) | on the local network only | announces the computer's name so other devices on your network can find it, and answers local name queries | `sudo systemctl disable --now avahi-daemon` |
+
+The time zone is never guessed from the network. Nothing in this table goes to the LordOS project.
+
+### Only when you ask
+
+These connections happen only after an action of yours:
+
+- **Store and updates:** the package lists and packages come from the Debian mirrors in your apt sources (`deb.debian.org` and `security.debian.org` by default; on the Raspberry Pi, the kernel and firmware come from `archive.raspberrypi.com`). The Store refreshes them only when you press **Check for updates** (in the Store or in Settings → Updates) or install something, and checks every list with Debian's signatures. LordOS's own `.lpk` apps are installed from files you choose; there is no online LordOS catalog.
+- **Language packages:** adding a language in Settings can install its dictionaries and fonts from the same Debian mirrors.
+- **Printers and scanners:** Settings → Printers & Scanners asks the local network (mDNS) which printers and scanners are there, and talks only to local addresses.
+- **Mail, Calendar and Contacts:** they connect only to the servers of the accounts you add (IMAP, SMTP, CalDAV, CardDAV). Remote images in messages are blocked until you press **Load Images**, and tracking pixels are removed.
+- **Wi-Fi, Bluetooth and VPNs:** only the networks, devices and VPN servers you choose.
+- **Remote desktop** is **off** by default (port 5673 closed). It listens only after you turn it on in Settings → Sharing. On the Raspberry Pi, remote desktop and the SSH server also stay off unless you put a `remote-desktop` or `ssh` switch file on the boot partition.
+- **Web browsers and other apps:** Firefox ESR, Chromium and any Linux app you install are separate programs from their own projects. They make the connections their settings allow, under their own privacy policies. Isolated `.lpk` apps reach the network only if you grant them the permission, and the per-app firewall shows and controls what each app connects to.
+- **The Debian installer script** (`curl -fsSL https://lordos.org/install.sh | sh`) contacts only `api.github.com` (to find the latest release), `github.com` (to download it and its signature) and your apt mirrors. It sends no telemetry.
+
+### What stays on your computer
+
+- **Monitor's world map** uses an offline IP-to-country database (DB-IP Lite) shipped with LordOS. Looking up where a connection goes never asks a server.
+- **Passwords:** the vault is encrypted on your disk and its process has no network access. The "breached password" check is offline only.
+- **Settings, mail, files and logs** stay on your computer. Logs are not uploaded anywhere.
+
+## Part 3: your rights, contact and changes
+
+### Your rights
+
+Because we don't collect personal data through the website or the distribution, there is usually nothing about you for us to access, correct or delete. For anything we do hold (an email you sent us, a donation record), you can ask to see it, correct it or delete it, subject to the records we must keep by law. If you are in Argentina, Law 25.326 on personal data protection gives you these rights, and you can complain to the Agency of Access to Public Information (AAIP). If you are in the European Union, Brazil or another country with similar laws (GDPR, LGPD), you have the rights those laws give you.
+
+### Contact
+
+Privacy questions or requests: [[CONTACT_EMAIL]].
+
+### Changes
+
+If LordOS or the website starts making a new kind of connection, or this policy changes in any other way, we will update this page first and change the date at the top.
diff --git a/web/content/legal/privacy.es.md b/web/content/legal/privacy.es.md
new file mode 100644
index 0000000..5ad2fa5
--- /dev/null
+++ b/web/content/legal/privacy.es.md
@@ -0,0 +1,85 @@
+LordOS no tiene cuentas, ni publicidad, ni rastreo, ni en el sitio ni en la distribución. Nadie vende, comparte ni guarda tus datos, porque nunca los recolectamos. Esta política tiene dos partes: el **sitio lordos.org** y la **distribución LordOS** que instalás en tu computadora.
+
+## Parte 1: el sitio
+
+### Qué guarda tu navegador
+
+El sitio es un conjunto de páginas estáticas. **No usa cookies** y guarda solo dos valores en el `localStorage` de tu navegador, en tu dispositivo:
+
+| Clave | Qué contiene | Para qué |
+|---|---|---|
+| `lordos-theme` | `light` o `dark` (nada si usás el automático) | para mostrar el tema que elegiste |
+| `lordos-lang-seen` | `1` | para que la sugerencia "esta página también está en tu idioma" aparezca una sola vez |
+
+Nunca salen de tu navegador y nosotros no podemos leerlos. Podés borrarlos cuando quieras desde la configuración de datos de sitios de tu navegador. Mirá el [Aviso de cookies](/legal/cookies/).
+
+### Sin estadísticas, sin publicidad, sin código de terceros
+
+El sitio no carga estadísticas de visitas, ni publicidad, ni widgets de redes sociales, ni fuentes o scripts de otros servidores: todo lo que necesita se sirve desde lordos.org.
+
+### Registros del servidor
+
+El sitio está alojado en Amazon Web Services (S3 y CloudFront). Como en cualquier sitio, tu navegador envía tu dirección IP y los datos habituales de la solicitud (la página pedida, la hora, el agente de usuario del navegador) para recibir la página. Nuestro proveedor de alojamiento puede guardar registros estándar de solicitudes de la CDN por seguridad, durante un tiempo limitado. No los usamos para identificar ni perfilar a quienes nos visitan.
+
+### Descargas en GitHub
+
+La imagen ISO, la imagen para Raspberry Pi, el paquete `.deb` y sus firmas están alojados en GitHub Releases. Cuando los descargás, o cuando el script de instalación para Debian los busca, GitHub recibe tu solicitud según la [declaración de privacidad de GitHub](https://docs.github.com/es/site-policy/privacy-policies/github-general-privacy-statement).
+
+### Donaciones
+
+Los botones de donación te llevan a PayPal o a Mercado Pago (y, más adelante, a Binance). El pago se hace por completo en sus sitios: nunca vemos ni guardamos los datos de tu tarjeta o de tu cuenta. El procesador nos informa el monto, la fecha y el nombre o el email que le diste, que guardamos solo para nuestra contabilidad. Se aplican sus propias políticas: [PayPal](https://www.paypal.com/myaccount/privacy/privacyhub), [Mercado Pago](https://www.mercadopago.com.ar/privacidad). Mirá los [Términos de las donaciones](/legal/donations/).
+
+### Email
+
+Si nos escribís, guardamos tu mensaje y tu dirección solo para responderte y hacer el seguimiento del tema.
+
+## Parte 2: la distribución LordOS
+
+### Sin telemetría
+
+LordOS **no envía telemetría**: ni estadísticas de uso, ni informes de fallos, ni identificadores del dispositivo, ni comprobaciones que "llamen a casa", ni inicio de sesión en una cuenta. No se nos envía nada sobre vos ni sobre tu computadora.
+
+### A qué se conecta LordOS de forma predeterminada
+
+Estas son las únicas conexiones de red que hace una instalación nueva de LordOS sin que vos pidas algo:
+
+| Conexión | Cuándo | Para qué | Cómo desactivarla |
+|---|---|---|---|
+| **DHCP y DNS** en tu red local | cuando hay un cable de red o una red Wi-Fi conectada | para obtener una dirección y resolver nombres; el DNS va a los servidores que te da tu red o los que configures | desconectate, o configurá una dirección y un DNS manuales en Ajustes → Red |
+| **Hora de red (NTP)** con `systemd-timesyncd`, contra el grupo público de servidores NTP de Debian | cuando la computadora está conectada | para mantener la hora correcta | Ajustes → Fecha y hora → desactivá "Ajustar la fecha y la hora automáticamente" |
+| **mDNS** (`avahi-daemon`, en PC; la imagen para Raspberry Pi no lo incluye) | solo en la red local | anuncia el nombre de la computadora para que otros dispositivos de tu red la encuentren, y responde consultas de nombres locales | `sudo systemctl disable --now avahi-daemon` |
+
+La zona horaria nunca se deduce a partir de la red. Nada de esta tabla llega al proyecto LordOS.
+
+### Solo cuando lo pedís
+
+Estas conexiones se hacen solo después de una acción tuya:
+
+- **Tienda y actualizaciones:** las listas de paquetes y los paquetes vienen de los servidores espejo de Debian que tengas en tus fuentes de apt (`deb.debian.org` y `security.debian.org` por defecto; en la Raspberry Pi, el kernel y el firmware vienen de `archive.raspberrypi.com`). La Tienda los actualiza solo cuando tocás **Buscar actualizaciones** (en la Tienda o en Ajustes → Actualizaciones) o instalás algo, y verifica cada lista con las firmas de Debian. Las apps `.lpk` propias de LordOS se instalan desde archivos que vos elegís; no hay un catálogo de LordOS en línea.
+- **Paquetes de idioma:** agregar un idioma en Ajustes puede instalar sus diccionarios y fuentes desde los mismos servidores espejo de Debian.
+- **Impresoras y escáneres:** Ajustes → Impresoras y escáneres le pregunta a la red local (mDNS) qué impresoras y escáneres hay, y habla solo con direcciones locales.
+- **Mail, Calendario y Contactos:** se conectan solo a los servidores de las cuentas que agregues (IMAP, SMTP, CalDAV, CardDAV). Las imágenes remotas de los mensajes quedan bloqueadas hasta que tocás **Cargar imágenes**, y los píxeles de rastreo se quitan.
+- **Wi-Fi, Bluetooth y VPN:** solo las redes, los dispositivos y los servidores VPN que elijas.
+- **El escritorio remoto** está **desactivado** por defecto (puerto 5673 cerrado). Solo escucha después de que lo activás en Ajustes → Compartir. En la Raspberry Pi, el escritorio remoto y el servidor SSH también quedan desactivados salvo que pongas un archivo interruptor `remote-desktop` o `ssh` en la partición de arranque.
+- **Navegadores web y otras apps:** Firefox ESR, Chromium y cualquier app de Linux que instales son programas aparte, de sus propios proyectos. Hacen las conexiones que permita su configuración, según sus propias políticas de privacidad. Las apps `.lpk` aisladas llegan a la red solo si les das el permiso, y el firewall por app muestra y controla a qué se conecta cada una.
+- **El script de instalación para Debian** (`curl -fsSL https://lordos.org/install.sh | sh`) se conecta solo a `api.github.com` (para encontrar la última versión), a `github.com` (para descargarla junto con su firma) y a tus servidores espejo de apt. No envía telemetría.
+
+### Lo que queda en tu computadora
+
+- **El mapa del mundo de Monitor** usa una base de datos de IP a país sin conexión (DB-IP Lite) que viene con LordOS. Averiguar adónde va una conexión nunca le pregunta a un servidor.
+- **Contraseñas:** la bóveda está cifrada en tu disco y su proceso no tiene acceso a la red. La comprobación de "contraseñas filtradas" es solo sin conexión.
+- **Los ajustes, el correo, los archivos y los registros** quedan en tu computadora. Los registros no se suben a ningún lado.
+
+## Parte 3: tus derechos, contacto y cambios
+
+### Tus derechos
+
+Como no recolectamos datos personales a través del sitio ni de la distribución, normalmente no tenemos nada tuyo para que consultes, corrijas o borres. Sobre lo que sí tengamos (un email que nos mandaste, el registro de una donación), podés pedir verlo, corregirlo o borrarlo, salvo los registros que debamos conservar por ley. Si estás en Argentina, la Ley 25.326 de Protección de Datos Personales te da estos derechos, y podés presentar un reclamo ante la Agencia de Acceso a la Información Pública (AAIP). Si estás en la Unión Europea, en Brasil o en otro país con leyes similares (RGPD, LGPD), tenés los derechos que te dan esas leyes.
+
+### Contacto
+
+Consultas o pedidos sobre privacidad: [[CONTACT_EMAIL]].
+
+### Cambios
+
+Si LordOS o el sitio empiezan a hacer un tipo de conexión nuevo, o si esta política cambia de cualquier otra forma, primero vamos a actualizar esta página y a cambiar la fecha al principio.
diff --git a/web/content/legal/privacy.pt.md b/web/content/legal/privacy.pt.md
new file mode 100644
index 0000000..e9e2cf0
--- /dev/null
+++ b/web/content/legal/privacy.pt.md
@@ -0,0 +1,85 @@
+O LordOS não tem contas, publicidade nem rastreamento, nem no site nem na distribuição. Ninguém vende, compartilha ou guarda os seus dados, porque nunca os coletamos. Esta política tem duas partes: o **site lordos.org** e a **distribuição LordOS** que você instala no seu computador.
+
+## Parte 1: o site
+
+### O que o seu navegador guarda
+
+O site é um conjunto de páginas estáticas. Ele **não define cookies** e guarda apenas dois valores no `localStorage` do seu navegador, no seu dispositivo:
+
+| Chave | O que contém | Para quê |
+|---|---|---|
+| `lordos-theme` | `light` ou `dark` (nada quando você usa o automático) | para mostrar o tema que você escolheu |
+| `lordos-lang-seen` | `1` | para que a sugestão "esta página também está no seu idioma" apareça só uma vez |
+
+Esses valores nunca saem do seu navegador e nós não podemos lê-los. Apague-os quando quiser nas configurações de dados de sites do navegador. Veja o [Aviso de cookies](/legal/cookies/).
+
+### Sem análises, sem anúncios, sem código de terceiros
+
+O site não carrega ferramentas de análise, publicidade, widgets de redes sociais nem fontes ou scripts de outros servidores: tudo o que ele precisa é servido por lordos.org.
+
+### Registros do servidor
+
+O site é hospedado na Amazon Web Services (S3 e CloudFront). Como em qualquer site, o seu navegador envia o seu endereço IP e os dados normais de uma requisição (a página pedida, o horário, o user agent do navegador) para receber a página. O nosso provedor de hospedagem pode manter registros padrão de requisições da CDN por motivos de segurança, por um tempo limitado. Não os usamos para identificar nem traçar o perfil de visitantes.
+
+### Downloads no GitHub
+
+A imagem ISO, a imagem para Raspberry Pi, o pacote `.deb` e as assinaturas deles ficam hospedados no GitHub Releases. Quando você os baixa, ou quando o script de instalação para Debian os busca, o GitHub recebe a sua requisição conforme a [declaração de privacidade do GitHub](https://docs.github.com/pt/site-policy/privacy-policies/github-general-privacy-statement).
+
+### Doações
+
+Os botões de doação levam você ao PayPal ou ao Mercado Pago (e, mais adiante, à Binance). O pagamento acontece inteiramente nos sites deles: nunca vemos nem guardamos os dados do seu cartão ou da sua conta. O processador nos informa o valor, a data e o nome ou e-mail que você forneceu a ele, que guardamos apenas para a nossa contabilidade. Valem as políticas deles: [PayPal](https://www.paypal.com/myaccount/privacy/privacyhub), [Mercado Pago](https://www.mercadopago.com.ar/privacidad). Veja os [Termos das doações](/legal/donations/).
+
+### E-mail
+
+Se você nos escrever, guardamos a sua mensagem e o seu endereço apenas para responder e acompanhar o assunto.
+
+## Parte 2: a distribuição LordOS
+
+### Sem telemetria
+
+O LordOS **não envia telemetria**: nada de estatísticas de uso, relatórios de falhas, identificadores do dispositivo, verificações que "ligam para casa" ou login em contas. Nada sobre você ou o seu computador é enviado para nós.
+
+### A que o LordOS se conecta por padrão
+
+Estas são as únicas conexões de rede que uma instalação nova do LordOS faz sem que você peça algo:
+
+| Conexão | Quando | Por quê | Como desligar |
+|---|---|---|---|
+| **DHCP e DNS** na sua rede local | quando um cabo de rede ou uma rede Wi-Fi está conectado | para obter um endereço e resolver nomes; o DNS vai para os servidores que a sua rede fornece ou que você define | desconecte, ou defina endereço e DNS manuais em Ajustes → Rede |
+| **Hora pela rede (NTP)** via `systemd-timesyncd`, para o pool público de NTP do Debian | quando o computador está on-line | para manter o relógio certo | Ajustes → Data e hora → desligue a hora automática |
+| **mDNS** (`avahi-daemon`, em PCs; a imagem para Raspberry Pi não o inclui) | apenas na rede local | anuncia o nome do computador para que outros dispositivos da sua rede o encontrem, e responde a consultas de nomes locais | `sudo systemctl disable --now avahi-daemon` |
+
+O fuso horário nunca é deduzido pela rede. Nada nesta tabela vai para o projeto LordOS.
+
+### Só quando você pede
+
+Estas conexões acontecem só depois de uma ação sua:
+
+- **Loja e atualizações:** as listas de pacotes e os pacotes vêm dos espelhos do Debian configurados nas suas fontes do apt (`deb.debian.org` e `security.debian.org` por padrão; no Raspberry Pi, o kernel e o firmware vêm de `archive.raspberrypi.com`). A Loja só as atualiza quando você toca em **Procurar atualizações** (na Loja ou em Ajustes → Atualizações) ou instala algo, e confere cada lista com as assinaturas do Debian. Os apps `.lpk` do LordOS são instalados a partir de arquivos que você escolhe; não existe um catálogo on-line do LordOS.
+- **Pacotes de idioma:** adicionar um idioma em Ajustes pode instalar os dicionários e as fontes dele a partir dos mesmos espelhos do Debian.
+- **Impressoras e scanners:** Ajustes → Impressoras e scanners pergunta à rede local (mDNS) quais impressoras e scanners existem nela, e só fala com endereços locais.
+- **Mail, Calendário e Contatos:** conectam-se apenas aos servidores das contas que você adiciona (IMAP, SMTP, CalDAV, CardDAV). As imagens remotas das mensagens ficam bloqueadas até você tocar em **Carregar imagens**, e os pixels de rastreamento são removidos.
+- **Wi-Fi, Bluetooth e VPNs:** apenas as redes, os dispositivos e os servidores VPN que você escolhe.
+- **A área de trabalho remota** vem **desligada** por padrão (porta 5673 fechada). Ela só escuta depois que você a liga em Ajustes → Compartilhar. No Raspberry Pi, a área de trabalho remota e o servidor SSH também ficam desligados, a menos que você coloque um arquivo de ativação `remote-desktop` ou `ssh` na partição de boot.
+- **Navegadores e outros apps:** o Firefox ESR, o Chromium e qualquer app Linux que você instalar são programas separados, de seus próprios projetos. Eles fazem as conexões que as configurações deles permitem, sob as políticas de privacidade deles. Os apps `.lpk` isolados só acessam a rede se você der a permissão, e o firewall por app mostra e controla a que cada app se conecta.
+- **O script de instalação para Debian** (`curl -fsSL https://lordos.org/install.sh | sh`) contata apenas `api.github.com` (para encontrar a última versão), `github.com` (para baixá-la com a assinatura) e os seus espelhos do apt. Ele não envia telemetria.
+
+### O que fica no seu computador
+
+- **O mapa-múndi do Monitor** usa um banco de dados offline de IP para país (DB-IP Lite) que vem com o LordOS. Descobrir para onde vai uma conexão nunca consulta um servidor.
+- **Senhas:** o cofre fica criptografado no seu disco e o processo dele não tem acesso à rede. A verificação de "senha vazada" é apenas offline.
+- **Configurações, e-mails, arquivos e registros** ficam no seu computador. Os registros não são enviados para lugar nenhum.
+
+## Parte 3: seus direitos, contato e alterações
+
+### Seus direitos
+
+Como não coletamos dados pessoais pelo site nem pela distribuição, normalmente não há nada sobre você para acessarmos, corrigirmos ou apagarmos. Para o que de fato guardamos (um e-mail que você nos enviou, um registro de doação), você pode pedir para ver, corrigir ou apagar, respeitados os registros que a lei nos obriga a manter. No Brasil, a Lei Geral de Proteção de Dados (LGPD, Lei 13.709/2018) garante esses direitos, e você pode apresentar reclamação à Autoridade Nacional de Proteção de Dados (ANPD). Na Argentina, a Lei 25.326 de proteção de dados pessoais dá esses direitos, com reclamação perante a Agência de Acesso à Informação Pública (AAIP). Na União Europeia ou em outro país com leis semelhantes (como o GDPR), você tem os direitos que essas leis lhe dão.
+
+### Contato
+
+Dúvidas ou pedidos sobre privacidade: [[CONTACT_EMAIL]].
+
+### Alterações
+
+Se o LordOS ou o site passar a fazer um novo tipo de conexão, ou se esta política mudar de qualquer outra forma, atualizaremos esta página antes e mudaremos a data no topo.
diff --git a/web/content/legal/security.en.md b/web/content/legal/security.en.md
new file mode 100644
index 0000000..f7fce58
--- /dev/null
+++ b/web/content/legal/security.en.md
@@ -0,0 +1,74 @@
+We take the security of LordOS seriously and we're grateful to anyone who helps us find and fix problems. This page explains how to report a vulnerability and what you can expect from us.
+
+## How to report a vulnerability
+
+Write to **[[SECURITY_EMAIL]]**. Please don't open a public issue, post on social media or publish details until a fix is out.
+
+Include, as far as you can:
+
+- the LordOS version (shown in the About LordOS app, for example "0.7.0 · Beta") and whether it is the ISO, the Raspberry Pi image or the Debian package;
+- the component affected (for example the compositor, the app sandbox, the per-app firewall, remote desktop, the password vault, the Store, the Debian installer script or the website);
+- the steps to reproduce it, a proof of concept if you have one, and the impact you see;
+- how you'd like to be credited, if at all.
+
+You can write in English, Spanish or Portuguese.
+
+## Scope
+
+**In scope:**
+
+- LordOS's own code: `lord-server` (the display server and Wayland compositor), `lord-sessiond` and the login screen, the app sandbox and permission broker, `lord-netperm`, `lord-vault`, the mail, document and media helpers, the package engine, the native apps and the SDK;
+- the release files and their signatures, and the Debian installer script (`lordos.org/install.sh`);
+- the configuration LordOS ships for the system (for example services it enables);
+- the lordos.org website.
+
+**Out of scope** (report these to their own projects):
+
+- vulnerabilities in Debian packages, the Linux kernel, Mesa, browsers or other third-party software that also affect plain Debian ([Debian's security team](https://www.debian.org/security/)); tell us too if LordOS makes it worse;
+- third-party `.lpk` apps (report to their author; tell us if one escapes the sandbox);
+- attacks that need physical access to an unlocked computer, social engineering, or denial of service by flooding;
+- reports from automated scanners without a demonstrated impact, and missing best-practice headers with no security consequence.
+
+## Safe harbour
+
+If you act in good faith and follow this policy, we will consider your research authorised, we won't take legal action against you, and we'll say so if anyone else does. Good faith means that you:
+
+- test only on your own computers, virtual machines and accounts;
+- don't access, change or delete other people's data, and stop as soon as you reach any;
+- don't degrade the website or other users' systems;
+- give us a reasonable time to fix the problem before disclosing it.
+
+## What to expect
+
+We are a small team, so these are our goals, not guarantees:
+
+| Step | Target |
+|---|---|
+| We acknowledge your report | within 3 business days |
+| We confirm the problem and tell you how serious we think it is | within 10 business days |
+| We fix critical and high-severity problems | as fast as possible, usually within 30 days |
+| Coordinated public disclosure | when the fix is released, or after 90 days, whichever comes first, unless we agree otherwise |
+
+We'll keep you informed, credit you in the release notes if you want, and publish an advisory for fixed vulnerabilities. We don't offer paid bug bounties at this time.
+
+## Verifying releases
+
+Every release file (the ISO, the Raspberry Pi image and the `.deb`) is listed with its SHA-256 in `SHA256SUMS`, and `SHA256SUMS` is signed with the LordOS release key (Ed25519). The Debian installer script refuses to install when the signature is missing or invalid.
+
+- Public key: [lordos-release.pub.pem](/lordos-release.pub.pem)
+- Fingerprint (SHA-256 of the DER public key):
+ `c7155b8e6bbbb180f907381994d06af76d333016cd6f3facf67cadd053ea108e`
+
+To check a download by hand:
+
+```
+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
+```
+
+If the fingerprint you see doesn't match the one above, don't install the file and tell us.
+
+## security.txt
+
+This policy is also published in machine-readable form at [/.well-known/security.txt](/.well-known/security.txt) (RFC 9116).
diff --git a/web/content/legal/security.es.md b/web/content/legal/security.es.md
new file mode 100644
index 0000000..c5b86ce
--- /dev/null
+++ b/web/content/legal/security.es.md
@@ -0,0 +1,74 @@
+Nos tomamos en serio la seguridad de LordOS y agradecemos a cualquiera que nos ayude a encontrar y corregir problemas. Esta página explica cómo reportar una vulnerabilidad y qué podés esperar de nosotros.
+
+## Cómo reportar una vulnerabilidad
+
+Escribinos a **[[SECURITY_EMAIL]]**. Por favor, no abras un issue público, no lo publiques en redes sociales ni des detalles hasta que salga una corrección.
+
+Incluí, en la medida de lo posible:
+
+- la versión de LordOS (la ves en la app Acerca de LordOS, por ejemplo "0.7.0 · Beta") y si es la ISO, la imagen para Raspberry Pi o el paquete para Debian;
+- el componente afectado (por ejemplo el compositor, el aislamiento de apps, el firewall por app, el escritorio remoto, la bóveda de contraseñas, la Tienda, el script de instalación para Debian o el sitio);
+- los pasos para reproducirlo, una prueba de concepto si la tenés, y el impacto que ves;
+- cómo te gustaría que te mencionemos, si querés que lo hagamos.
+
+Podés escribir en inglés, español o portugués.
+
+## Alcance
+
+**Dentro del alcance:**
+
+- el código propio de LordOS: `lord-server` (el servidor gráfico y compositor Wayland), `lord-sessiond` y la pantalla de inicio de sesión, el aislamiento de apps y el intermediario de permisos, `lord-netperm`, `lord-vault`, los procesos auxiliares de correo, documentos y multimedia, el motor de paquetes, las apps nativas y el SDK;
+- los archivos de cada versión y sus firmas, y el script de instalación para Debian (`lordos.org/install.sh`);
+- la configuración del sistema que trae LordOS (por ejemplo, los servicios que activa);
+- el sitio lordos.org.
+
+**Fuera del alcance** (reportalos a sus propios proyectos):
+
+- vulnerabilidades de paquetes de Debian, del kernel Linux, de Mesa, de los navegadores o de otro software de terceros que también afecten a un Debian común ([equipo de seguridad de Debian](https://www.debian.org/security/)); avisanos también si LordOS lo empeora;
+- apps `.lpk` de terceros (reportalas a su autor; avisanos si alguna escapa del aislamiento);
+- ataques que requieran acceso físico a una computadora desbloqueada, ingeniería social, o denegación de servicio por saturación;
+- reportes de escáneres automáticos sin un impacto demostrado, y encabezados de buenas prácticas faltantes sin consecuencias de seguridad.
+
+## Puerto seguro
+
+Si actuás de buena fe y seguís esta política, vamos a considerar autorizada tu investigación, no vamos a iniciar acciones legales en tu contra y lo vamos a dejar claro si otra persona lo hace. Actuar de buena fe significa que:
+
+- probás solo en tus propias computadoras, máquinas virtuales y cuentas;
+- no accedés, cambiás ni borrás datos de otras personas, y frenás apenas llegás a alguno;
+- no degradás el sitio ni los sistemas de otros usuarios;
+- nos das un tiempo razonable para corregir el problema antes de hacerlo público.
+
+## Qué podés esperar
+
+Somos un equipo chico, así que estos son nuestros objetivos, no garantías:
+
+| Paso | Objetivo |
+|---|---|
+| Confirmamos que recibimos tu reporte | dentro de 3 días hábiles |
+| Confirmamos el problema y te decimos qué tan grave nos parece | dentro de 10 días hábiles |
+| Corregimos los problemas críticos y de gravedad alta | lo antes posible, normalmente dentro de 30 días |
+| Divulgación pública coordinada | cuando sale la corrección, o a los 90 días, lo que ocurra primero, salvo que acordemos otra cosa |
+
+Te vamos a mantener al tanto, te vamos a mencionar en las notas de la versión si querés, y vamos a publicar un aviso por cada vulnerabilidad corregida. Por ahora no ofrecemos recompensas pagas por errores.
+
+## Verificar las versiones
+
+Cada archivo de una versión (la ISO, la imagen para Raspberry Pi y el `.deb`) figura con su SHA-256 en `SHA256SUMS`, y `SHA256SUMS` está firmado con la clave de versiones de LordOS (Ed25519). El script de instalación para Debian se niega a instalar si la firma falta o no es válida.
+
+- Clave pública: [lordos-release.pub.pem](/lordos-release.pub.pem)
+- Huella (SHA-256 de la clave pública en DER):
+ `c7155b8e6bbbb180f907381994d06af76d333016cd6f3facf67cadd053ea108e`
+
+Para verificar una descarga a mano:
+
+```
+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
+```
+
+Si la huella que ves no coincide con la de arriba, no instales el archivo y avisanos.
+
+## security.txt
+
+Esta política también está publicada en un formato legible por máquinas en [/.well-known/security.txt](/.well-known/security.txt) (RFC 9116).
diff --git a/web/content/legal/security.pt.md b/web/content/legal/security.pt.md
new file mode 100644
index 0000000..76a17ce
--- /dev/null
+++ b/web/content/legal/security.pt.md
@@ -0,0 +1,74 @@
+Levamos a segurança do LordOS a sério e agradecemos a quem nos ajuda a encontrar e corrigir problemas. Esta página explica como relatar uma vulnerabilidade e o que você pode esperar de nós.
+
+## Como relatar uma vulnerabilidade
+
+Escreva para **[[SECURITY_EMAIL]]**. Por favor, não abra uma issue pública, não publique em redes sociais nem divulgue detalhes até que uma correção esteja disponível.
+
+Inclua, na medida do possível:
+
+- a versão do LordOS (no app Sobre o LordOS, por exemplo "0.7.0 · Beta") e se é a ISO, a imagem para Raspberry Pi ou o pacote do Debian;
+- o componente afetado (por exemplo o compositor, o sandbox de apps, o firewall por app, a área de trabalho remota, o cofre de senhas, a Loja, o script de instalação para Debian ou o site);
+- os passos para reproduzir, uma prova de conceito se você tiver, e o impacto que você vê;
+- como você gostaria de ser creditado, se quiser.
+
+Você pode escrever em inglês, espanhol ou português.
+
+## Escopo
+
+**Dentro do escopo:**
+
+- o código próprio do LordOS: `lord-server` (o servidor gráfico e compositor Wayland), `lord-sessiond` e a tela de login, o sandbox de apps e o intermediário de permissões, `lord-netperm`, `lord-vault`, os auxiliares de e-mail, documentos e mídia, o motor de pacotes, os apps nativos e o SDK;
+- os arquivos de release e as suas assinaturas, e o script de instalação para Debian (`lordos.org/install.sh`);
+- a configuração que o LordOS aplica ao sistema (por exemplo os serviços que ele ativa);
+- o site lordos.org.
+
+**Fora do escopo** (relate-os aos seus próprios projetos):
+
+- vulnerabilidades em pacotes do Debian, no kernel Linux, no Mesa, em navegadores ou em outro software de terceiros que também afetam o Debian puro ([equipe de segurança do Debian](https://www.debian.org/security/)); avise-nos também se o LordOS piorar o problema;
+- apps `.lpk` de terceiros (relate ao autor; avise-nos se algum escapar do sandbox);
+- ataques que exigem acesso físico a um computador desbloqueado, engenharia social ou negação de serviço por inundação;
+- relatórios de scanners automáticos sem impacto demonstrado, e cabeçalhos de boas práticas ausentes sem consequência de segurança.
+
+## Porto seguro
+
+Se você agir de boa-fé e seguir esta política, consideraremos a sua pesquisa autorizada, não tomaremos medidas legais contra você e diremos isso se outra pessoa o fizer. Boa-fé significa que você:
+
+- testa apenas nos seus próprios computadores, máquinas virtuais e contas;
+- não acessa, altera nem apaga dados de outras pessoas, e para assim que chegar a algum;
+- não prejudica o site nem os sistemas de outros usuários;
+- nos dá um prazo razoável para corrigir o problema antes de divulgá-lo.
+
+## O que esperar
+
+Somos uma equipe pequena, então estas são metas, não garantias:
+
+| Etapa | Meta |
+|---|---|
+| Confirmamos o recebimento do seu relato | em até 3 dias úteis |
+| Confirmamos o problema e dizemos qual gravidade achamos que ele tem | em até 10 dias úteis |
+| Corrigimos problemas críticos e de alta gravidade | o mais rápido possível, normalmente em até 30 dias |
+| Divulgação pública coordenada | quando a correção for publicada, ou após 90 dias, o que vier primeiro, salvo acordo diferente |
+
+Manteremos você informado, daremos o crédito nas notas de versão se você quiser e publicaremos um aviso para as vulnerabilidades corrigidas. No momento não oferecemos recompensas pagas por falhas.
+
+## Verificar as releases
+
+Cada arquivo de release (a ISO, a imagem para Raspberry Pi e o `.deb`) aparece com o seu SHA-256 em `SHA256SUMS`, e `SHA256SUMS` é assinado com a chave de release do LordOS (Ed25519). O script de instalação para Debian se recusa a instalar quando a assinatura está ausente ou é inválida.
+
+- Chave pública: [lordos-release.pub.pem](/lordos-release.pub.pem)
+- Impressão digital (SHA-256 da chave pública em DER):
+ `c7155b8e6bbbb180f907381994d06af76d333016cd6f3facf67cadd053ea108e`
+
+Para conferir um download manualmente:
+
+```
+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
+```
+
+Se a impressão digital que você vê não for igual à de cima, não instale o arquivo e avise-nos.
+
+## security.txt
+
+Esta política também é publicada em formato legível por máquinas em [/.well-known/security.txt](/.well-known/security.txt) (RFC 9116).
diff --git a/web/content/legal/terms.en.md b/web/content/legal/terms.en.md
new file mode 100644
index 0000000..f318630
--- /dev/null
+++ b/web/content/legal/terms.en.md
@@ -0,0 +1,49 @@
+These terms cover the lordos.org website and the LordOS files you download from it or from our GitHub releases (the ISO image, the Raspberry Pi image, the `.deb` package and the Debian installer script). LordOS is a free Debian-based GNU/Linux distribution with its own desktop environment, made by the IPERFEX group (Pablo Miranda and Federico Pereira, Argentina).
+
+## Acceptance
+
+By using this website or downloading, installing or running LordOS, you accept these terms. If you don't agree with them, don't use the website or the software.
+
+## Free software under the MIT license
+
+LordOS's own code is free software released under the [MIT license](https://github.com/lordbasex/LordOS/blob/main/LICENSE). You may use, copy, modify and redistribute it under that license. The license, not these terms, governs what you may do with the code; these terms only add the rules for the website, the downloads and the LordOS name (see the [Trademark and brand policy](/legal/trademark/)).
+
+LordOS also includes software from Debian and other projects under their own licenses. See [Licenses and open-source notices](/legal/licenses/).
+
+## Beta software
+
+LordOS is in beta. Features may be incomplete, change or be removed, and there may be bugs that cause data loss or make a computer fail to start. Don't rely on it for critical work, and don't install it on a computer whose data you can't afford to lose.
+
+## No warranty
+
+LordOS and this website are provided **"as is"** and **"as available"**, without warranty of any kind, express or implied, including the warranties of merchantability, fitness for a particular purpose and non-infringement. We don't promise that the software will work on your hardware, be free of errors or security problems, or that the website will always be available.
+
+## Limitation of liability
+
+To the fullest extent the law allows, the IPERFEX group, the authors and the contributors are not liable for any damage arising from the use of, or the inability to use, the website or LordOS. That includes loss of data, loss of profits, hardware damage, interrupted work and any direct, indirect, incidental or consequential damage, even if we were told it could happen. Some jurisdictions don't allow some of these limits; in those, they apply as far as the law permits.
+
+## Your responsibility
+
+- **Back up first.** Installing a GNU/Linux distribution can erase a disk. Copy everything you care about to another device before you install LordOS, partition a disk, or run the Debian installer script.
+- **Check what you run.** Verify the download's SHA-256 and signature (see the [Security policy](/legal/security/)) and read what the installer is going to change before you confirm.
+- **Your computer, your choices.** You are responsible for how you install, configure and use LordOS, for the software you add to it, and for complying with the laws and licenses that apply to you.
+
+## Third-party software and links
+
+LordOS installs and runs software made by others (Debian packages, web browsers, Linux apps from the Store, `.lpk` apps by other developers). That software has its own licenses and terms, and its authors, not us, are responsible for it. The website links to other sites, such as GitHub, PayPal and Mercado Pago; we don't control them and are not responsible for their content or their practices.
+
+## Donations
+
+Donations are voluntary and don't buy any product, service, support or special treatment. They are covered by the [Donation terms](/legal/donations/).
+
+## Governing law
+
+These terms are governed by the laws of the Argentine Republic, and any dispute will be handled by the competent courts of [[ADDRESS]], unless the law of your country gives you a right that can't be waived. *(Pending confirmation by the project.)*
+
+## Changes
+
+We may update these terms. The date at the top of this page shows the last change. If you keep using the website or LordOS after a change, you accept the new terms.
+
+## Contact
+
+Questions about these terms: [[CONTACT_EMAIL]]. See also the [Legal notice](/legal/legal-notice/).
diff --git a/web/content/legal/terms.es.md b/web/content/legal/terms.es.md
new file mode 100644
index 0000000..c70fdad
--- /dev/null
+++ b/web/content/legal/terms.es.md
@@ -0,0 +1,49 @@
+Estos términos cubren el sitio lordos.org y los archivos de LordOS que descargás desde él o desde nuestras versiones en GitHub (la imagen ISO, la imagen para Raspberry Pi, el paquete `.deb` y el script de instalación para Debian). LordOS es una distribución GNU/Linux libre basada en Debian, con un entorno de escritorio propio, hecha por el grupo IPERFEX (Pablo Miranda y Federico Pereira, Argentina).
+
+## Aceptación
+
+Al usar este sitio o al descargar, instalar o ejecutar LordOS, aceptás estos términos. Si no estás de acuerdo, no uses el sitio ni el software.
+
+## Software libre bajo la licencia MIT
+
+El código propio de LordOS es software libre publicado bajo la [licencia MIT](https://github.com/lordbasex/LordOS/blob/main/LICENSE). Podés usarlo, copiarlo, modificarlo y redistribuirlo según esa licencia. Lo que podés hacer con el código lo rige la licencia, no estos términos; estos términos solo agregan las reglas para el sitio, las descargas y el nombre LordOS (mirá la [Política de marca](/legal/trademark/)).
+
+LordOS también incluye software de Debian y de otros proyectos, cada uno con su propia licencia. Mirá [Licencias y avisos de código abierto](/legal/licenses/).
+
+## Software en beta
+
+LordOS está en beta. Puede haber funciones incompletas, que cambien o que se quiten, y puede haber errores que provoquen pérdida de datos o que una computadora no arranque. No dependas de LordOS para trabajos críticos y no lo instales en una computadora cuyos datos no puedas perder.
+
+## Sin garantía
+
+LordOS y este sitio se ofrecen **"tal cual"** y **"según disponibilidad"**, sin garantía de ningún tipo, expresa ni implícita, incluidas las garantías de comerciabilidad, de idoneidad para un fin determinado y de no infracción. No prometemos que el software funcione en tu hardware, que no tenga errores ni problemas de seguridad, ni que el sitio esté siempre disponible.
+
+## Limitación de responsabilidad
+
+En la máxima medida que permita la ley, el grupo IPERFEX, los autores y los colaboradores no son responsables por ningún daño que surja del uso del sitio o de LordOS, o de la imposibilidad de usarlos. Eso incluye pérdida de datos, lucro cesante, daños al hardware, trabajo interrumpido y cualquier daño directo, indirecto, incidental o consecuente, aunque se nos haya advertido que podía ocurrir. Algunas jurisdicciones no permiten algunos de estos límites; en ellas, se aplican hasta donde la ley lo permita.
+
+## Tu responsabilidad
+
+- **Primero, hacé una copia de seguridad.** Instalar una distribución GNU/Linux puede borrar un disco. Copiá todo lo que te importe a otro dispositivo antes de instalar LordOS, particionar un disco o ejecutar el script de instalación para Debian.
+- **Revisá lo que ejecutás.** Verificá el SHA-256 y la firma de la descarga (mirá la [Política de seguridad](/legal/security/)) y leé qué va a cambiar el instalador antes de confirmar.
+- **Tu computadora, tus decisiones.** Sos responsable de cómo instalás, configurás y usás LordOS, del software que le agregás y de cumplir las leyes y licencias que te correspondan.
+
+## Software y enlaces de terceros
+
+LordOS instala y ejecuta software hecho por otros (paquetes de Debian, navegadores web, apps de Linux de la Tienda, apps `.lpk` de otros desarrolladores). Ese software tiene sus propias licencias y condiciones, y sus autores, no nosotros, son responsables de él. El sitio enlaza a otros sitios, como GitHub, PayPal y Mercado Pago; no los controlamos y no somos responsables de su contenido ni de sus prácticas.
+
+## Donaciones
+
+Las donaciones son voluntarias y no compran ningún producto, servicio, soporte ni trato especial. Se rigen por los [Términos de las donaciones](/legal/donations/).
+
+## Ley aplicable
+
+Estos términos se rigen por las leyes de la República Argentina, y cualquier controversia quedará a cargo de los tribunales competentes de [[ADDRESS]], salvo que la ley de tu país te dé un derecho al que no se pueda renunciar. *(Pendiente de confirmación por el proyecto.)*
+
+## Cambios
+
+Podemos actualizar estos términos. La fecha al principio de esta página indica el último cambio. Si seguís usando el sitio o LordOS después de un cambio, aceptás los términos nuevos.
+
+## Contacto
+
+Consultas sobre estos términos: [[CONTACT_EMAIL]]. Mirá también el [Aviso legal](/legal/legal-notice/).
diff --git a/web/content/legal/terms.pt.md b/web/content/legal/terms.pt.md
new file mode 100644
index 0000000..8d4d63b
--- /dev/null
+++ b/web/content/legal/terms.pt.md
@@ -0,0 +1,49 @@
+Estes termos se aplicam ao site lordos.org e aos arquivos do LordOS que você baixa dele ou das nossas releases no GitHub (a imagem ISO, a imagem para Raspberry Pi, o pacote `.deb` e o script de instalação para Debian). O LordOS é uma distribuição GNU/Linux livre baseada no Debian, com ambiente de desktop próprio, feita pelo grupo IPERFEX (Pablo Miranda e Federico Pereira, Argentina).
+
+## Aceitação
+
+Ao usar este site ou ao baixar, instalar ou executar o LordOS, você aceita estes termos. Se não concordar com eles, não use o site nem o software.
+
+## Software livre sob a licença MIT
+
+O código próprio do LordOS é software livre, publicado sob a [licença MIT](https://github.com/lordbasex/LordOS/blob/main/LICENSE). Você pode usá-lo, copiá-lo, modificá-lo e redistribuí-lo nos termos dessa licença. É a licença, e não estes termos, que define o que você pode fazer com o código; estes termos só acrescentam as regras do site, dos downloads e do nome LordOS (veja a [Política de marca](/legal/trademark/)).
+
+O LordOS também inclui software do Debian e de outros projetos, sob as licenças deles. Veja [Licenças e avisos de código aberto](/legal/licenses/).
+
+## Software em beta
+
+O LordOS está em beta. Recursos podem estar incompletos, mudar ou ser removidos, e pode haver erros que causem perda de dados ou impeçam o computador de iniciar. Não dependa dele para trabalhos críticos e não o instale em um computador cujos dados você não pode perder.
+
+## Sem garantia
+
+O LordOS e este site são fornecidos **"no estado em que se encontram"** e **"conforme disponíveis"**, sem garantia de nenhum tipo, expressa ou implícita, incluindo as garantias de comerciabilidade, adequação a um fim específico e não violação. Não prometemos que o software funcione no seu hardware, que esteja livre de erros ou de problemas de segurança, nem que o site esteja sempre disponível.
+
+## Limitação de responsabilidade
+
+Na máxima medida permitida pela lei, o grupo IPERFEX, os autores e os colaboradores não são responsáveis por nenhum dano decorrente do uso, ou da impossibilidade de uso, do site ou do LordOS. Isso inclui perda de dados, lucros cessantes, danos ao hardware, interrupção do trabalho e qualquer dano direto, indireto, incidental ou consequente, mesmo que tenhamos sido avisados de que poderia acontecer. Algumas jurisdições não permitem algumas dessas limitações; nelas, elas se aplicam até onde a lei permitir.
+
+## Sua responsabilidade
+
+- **Faça backup antes.** Instalar uma distribuição GNU/Linux pode apagar um disco. Copie tudo o que é importante para outro dispositivo antes de instalar o LordOS, particionar um disco ou executar o script de instalação para Debian.
+- **Confira o que você executa.** Verifique o SHA-256 e a assinatura do download (veja a [Política de segurança](/legal/security/)) e leia o que o instalador vai alterar antes de confirmar.
+- **Seu computador, suas escolhas.** Você é responsável por como instala, configura e usa o LordOS, pelo software que adiciona a ele e por cumprir as leis e licenças que se aplicam a você.
+
+## Software e links de terceiros
+
+O LordOS instala e executa software feito por outros (pacotes do Debian, navegadores, apps Linux da Loja, apps `.lpk` de outros desenvolvedores). Esse software tem suas próprias licenças e termos, e os autores dele, não nós, são responsáveis por ele. O site tem links para outros sites, como GitHub, PayPal e Mercado Pago; não os controlamos e não somos responsáveis pelo conteúdo nem pelas práticas deles.
+
+## Doações
+
+As doações são voluntárias e não compram nenhum produto, serviço, suporte ou tratamento especial. Elas seguem os [Termos das doações](/legal/donations/).
+
+## Lei aplicável
+
+Estes termos são regidos pelas leis da República Argentina, e qualquer controvérsia será tratada pelos tribunais competentes de [[ADDRESS]], salvo quando a lei do seu país lhe garantir um direito irrenunciável. *(Pendente de confirmação pelo projeto.)*
+
+## Alterações
+
+Podemos atualizar estes termos. A data no topo desta página mostra a última alteração. Se você continuar usando o site ou o LordOS depois de uma alteração, aceita os novos termos.
+
+## Contato
+
+Dúvidas sobre estes termos: [[CONTACT_EMAIL]]. Veja também o [Aviso legal](/legal/legal-notice/).
diff --git a/web/content/legal/trademark.en.md b/web/content/legal/trademark.en.md
new file mode 100644
index 0000000..1e1109a
--- /dev/null
+++ b/web/content/legal/trademark.en.md
@@ -0,0 +1,38 @@
+The LordOS code is free software under the MIT license, and you can do almost anything with it. The **LordOS name**, the **crown logo** and **Lumo**, the mascot, are different: they tell people that something comes from the LordOS project. This policy explains how you can use them so that nobody is misled.
+
+## What the brand includes
+
+- the name **LordOS** and the wordmark (**Lord**OS, set in Plus Jakarta Sans);
+- the crown logo, the app icon, the crown symbol and their variants;
+- **Lumo**, the guardian of LordOS, in every pose and drawing.
+
+The official files and the rules for using them (clear space, colours, minimum sizes) are in the [brand kit](https://github.com/lordbasex/LordOS/blob/main/docs/LORDOS-BRAND.md).
+
+## What you can do without asking
+
+- **Refer to the project** by name, for example "runs on LordOS", "a theme for LordOS" or "compatible with LordOS".
+- **Link** to lordos.org or the repository, with the name or the unmodified logo.
+- **Write about LordOS**: articles, reviews, videos, tutorials, books, talks and classes, using screenshots, the name and the logo.
+- **Use the logos and Lumo from the brand kit, unmodified**, following its rules: no stretching, recolouring, other fonts, effects or redrawing.
+- **Share unmodified LordOS images** (the ISO, the Raspberry Pi image or the `.deb`) as we publish them, for example on a mirror or a USB stick for a friend.
+- **Make community material**, such as stickers or wallpapers for yourself or a user group, as long as you don't sell it.
+
+## What needs our permission
+
+- **Implying endorsement:** don't suggest that the LordOS project or IPERFEX makes, sponsors, certifies or supports your product, service, company or event.
+- **Modified distributions:** if you change LordOS (other packages, code, settings or branding) and distribute the result, you can't call it LordOS or use the crown logo or Lumo without written permission.
+- **Commercial use of the brand:** selling merchandise with the logo or Lumo, or using them in advertising for a product.
+- **Names and domains:** using "LordOS" or something confusingly similar in the name of a product, company, app, distribution or domain name.
+- **Modified logos or a modified Lumo**, or new logos that imitate them.
+
+## Forks
+
+Forks are welcome; that's what free software is for. A fork must have **its own name and its own logo**, different from LordOS's and not confusingly similar, and must remove the crown logo, Lumo and the LordOS wordmark from the system and its website. You may say, truthfully, that it is "based on LordOS".
+
+## Asking for permission
+
+Write to [[CONTACT_EMAIL]] with what you want to do. We are usually glad to say yes to user groups, events and projects that help people use LordOS.
+
+## Other trademarks
+
+Debian is a registered trademark of Software in the Public Interest, Inc. Linux is the registered trademark of Linus Torvalds. Raspberry Pi is a trademark of Raspberry Pi Ltd. Other names belong to their owners. LordOS is not affiliated with or endorsed by them.
diff --git a/web/content/legal/trademark.es.md b/web/content/legal/trademark.es.md
new file mode 100644
index 0000000..9028655
--- /dev/null
+++ b/web/content/legal/trademark.es.md
@@ -0,0 +1,38 @@
+El código de LordOS es software libre bajo la licencia MIT, y podés hacer casi cualquier cosa con él. El **nombre LordOS**, el **logo de la corona** y **Lumo**, la mascota, son otra cosa: le indican a la gente que algo viene del proyecto LordOS. Esta política explica cómo podés usarlos para que nadie se confunda.
+
+## Qué incluye la marca
+
+- el nombre **LordOS** y el logotipo (**Lord**OS, en Plus Jakarta Sans);
+- el logo de la corona, el ícono de la app, el símbolo de la corona y sus variantes;
+- **Lumo**, el guardián de LordOS, en todas sus poses y dibujos.
+
+Los archivos oficiales y las reglas para usarlos (espacio libre, colores, tamaños mínimos) están en el [kit de marca](https://github.com/lordbasex/LordOS/blob/main/docs/LORDOS-BRAND.md).
+
+## Qué podés hacer sin pedir permiso
+
+- **Nombrar el proyecto**, por ejemplo "funciona en LordOS", "un tema para LordOS" o "compatible con LordOS".
+- **Enlazar** a lordos.org o al repositorio, con el nombre o con el logo sin modificar.
+- **Escribir sobre LordOS**: artículos, reseñas, videos, tutoriales, libros, charlas y clases, con capturas de pantalla, el nombre y el logo.
+- **Usar los logos y a Lumo del kit de marca, sin modificar**, siguiendo sus reglas: sin estirarlos, cambiarles el color, usar otras fuentes, agregar efectos ni redibujarlos.
+- **Compartir las imágenes de LordOS sin modificar** (la ISO, la imagen para Raspberry Pi o el `.deb`) tal como las publicamos, por ejemplo en un espejo o en un pendrive para un amigo.
+- **Hacer material para la comunidad**, como stickers o fondos de pantalla para vos o para un grupo de usuarios, siempre que no lo vendas.
+
+## Qué necesita nuestro permiso
+
+- **Dar a entender un respaldo:** no sugieras que el proyecto LordOS o IPERFEX hace, patrocina, certifica o respalda tu producto, servicio, empresa o evento.
+- **Distribuciones modificadas:** si cambiás LordOS (otros paquetes, código, configuración o marca) y distribuís el resultado, no podés llamarlo LordOS ni usar el logo de la corona ni a Lumo sin permiso por escrito.
+- **Uso comercial de la marca:** vender productos con el logo o con Lumo, o usarlos en la publicidad de un producto.
+- **Nombres y dominios:** usar "LordOS", o algo que se le parezca hasta confundirse, en el nombre de un producto, empresa, app, distribución o dominio.
+- **Logos modificados o un Lumo modificado**, o logos nuevos que los imiten.
+
+## Forks
+
+Los forks son bienvenidos; para eso está el software libre. Un fork tiene que tener **su propio nombre y su propio logo**, distintos de los de LordOS y que no se confundan con ellos, y tiene que quitar el logo de la corona, a Lumo y el logotipo de LordOS del sistema y de su sitio. Podés decir, si es verdad, que está "basado en LordOS".
+
+## Cómo pedir permiso
+
+Escribinos a [[CONTACT_EMAIL]] contándonos qué querés hacer. En general nos alegra decir que sí a grupos de usuarios, eventos y proyectos que ayudan a la gente a usar LordOS.
+
+## Otras marcas
+
+Debian es una marca registrada de Software in the Public Interest, Inc. Linux es la marca registrada de Linus Torvalds. Raspberry Pi es una marca de Raspberry Pi Ltd. Los demás nombres pertenecen a sus dueños. LordOS no está afiliado a ellos ni cuenta con su respaldo.
diff --git a/web/content/legal/trademark.pt.md b/web/content/legal/trademark.pt.md
new file mode 100644
index 0000000..92908ce
--- /dev/null
+++ b/web/content/legal/trademark.pt.md
@@ -0,0 +1,38 @@
+O código do LordOS é software livre sob a licença MIT, e você pode fazer quase tudo com ele. O **nome LordOS**, o **logo da coroa** e **Lumo**, o mascote, são outra coisa: eles dizem às pessoas que algo vem do projeto LordOS. Esta política explica como você pode usá-los sem enganar ninguém.
+
+## O que a marca inclui
+
+- o nome **LordOS** e o logotipo (**Lord**OS, em Plus Jakarta Sans);
+- o logo da coroa, o ícone do app, o símbolo da coroa e as suas variantes;
+- **Lumo**, o guardião do LordOS, em todas as poses e desenhos.
+
+Os arquivos oficiais e as regras de uso (área de proteção, cores, tamanhos mínimos) estão no [kit de marca](https://github.com/lordbasex/LordOS/blob/main/docs/LORDOS-BRAND.md).
+
+## O que você pode fazer sem pedir
+
+- **Mencionar o projeto** pelo nome, por exemplo "roda no LordOS", "um tema para o LordOS" ou "compatível com o LordOS".
+- **Criar links** para lordos.org ou para o repositório, com o nome ou com o logo sem modificações.
+- **Escrever sobre o LordOS**: artigos, análises, vídeos, tutoriais, livros, palestras e aulas, usando capturas de tela, o nome e o logo.
+- **Usar os logos e o Lumo do kit de marca, sem modificações**, seguindo as regras dele: sem esticar, mudar as cores, trocar a fonte, adicionar efeitos ou redesenhar.
+- **Compartilhar imagens do LordOS sem modificações** (a ISO, a imagem para Raspberry Pi ou o `.deb`) como nós as publicamos, por exemplo em um espelho ou em um pendrive para um amigo.
+- **Fazer material da comunidade**, como adesivos ou papéis de parede para você ou para um grupo de usuários, desde que não o venda.
+
+## O que precisa da nossa permissão
+
+- **Sugerir endosso:** não dê a entender que o projeto LordOS ou a IPERFEX faz, patrocina, certifica ou apoia o seu produto, serviço, empresa ou evento.
+- **Distribuições modificadas:** se você alterar o LordOS (outros pacotes, código, configurações ou identidade visual) e distribuir o resultado, não pode chamá-lo de LordOS nem usar o logo da coroa ou o Lumo sem permissão por escrito.
+- **Uso comercial da marca:** vender produtos com o logo ou o Lumo, ou usá-los na publicidade de um produto.
+- **Nomes e domínios:** usar "LordOS" ou algo que possa ser confundido com ele no nome de um produto, empresa, app, distribuição ou domínio.
+- **Logos ou um Lumo modificados**, ou novos logos que os imitem.
+
+## Forks
+
+Forks são bem-vindos; é para isso que existe o software livre. Um fork deve ter **um nome e um logo próprios**, diferentes dos do LordOS e que não possam ser confundidos com eles, e deve remover o logo da coroa, o Lumo e o logotipo LordOS do sistema e do seu site. Você pode dizer, com verdade, que ele é "baseado no LordOS".
+
+## Como pedir permissão
+
+Escreva para [[CONTACT_EMAIL]] contando o que você quer fazer. Normalmente ficamos felizes em dizer sim a grupos de usuários, eventos e projetos que ajudam as pessoas a usar o LordOS.
+
+## Outras marcas
+
+Debian é uma marca registrada da Software in the Public Interest, Inc. Linux é a marca registrada de Linus Torvalds. Raspberry Pi é uma marca da Raspberry Pi Ltd. Os demais nomes pertencem aos seus donos. O LordOS não é afiliado a eles nem endossado por eles.
diff --git a/web/content/paper/diagrams.json b/web/content/paper/diagrams.json
new file mode 100644
index 0000000..ef6df7c
--- /dev/null
+++ b/web/content/paper/diagrams.json
@@ -0,0 +1,798 @@
+{
+ "diagrams": [
+ {
+ "id": "layers",
+ "kind": "stack",
+ "title": {
+ "en": "The layers of LordOS",
+ "es": "Las capas de LordOS",
+ "pt": "As camadas do LordOS"
+ },
+ "nodes": [
+ {
+ "id": "apps",
+ "label": {
+ "en": "Apps",
+ "es": "Apps",
+ "pt": "Apps"
+ },
+ "sub": {
+ "en": "Built-in apps and the theme · isolated .lpk apps · Linux apps (GTK, Qt, browsers)",
+ "es": "Apps incluidas y el tema · apps .lpk aisladas · apps de Linux (GTK, Qt, navegadores)",
+ "pt": "Apps incluídos e o tema · apps .lpk isolados · apps Linux (GTK, Qt, navegadores)"
+ },
+ "tone": "user"
+ },
+ {
+ "id": "engine",
+ "label": {
+ "en": "LordOS UI engine",
+ "es": "Motor de interfaz de LordOS",
+ "pt": "Motor de interface do LordOS"
+ },
+ "sub": {
+ "en": "React on QuickJS, native layout, painting and text in C. Used by LordOS's own apps; Linux apps don't go through it",
+ "es": "React sobre QuickJS, layout, pintado y texto nativos en C. Lo usan las apps de LordOS; las apps de Linux no pasan por acá",
+ "pt": "React sobre QuickJS, layout, pintura e texto nativos em C. Usado pelos apps do LordOS; apps Linux não passam por ele"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "server",
+ "label": {
+ "en": "LordOS display server and Wayland compositor",
+ "es": "Servidor gráfico y compositor Wayland de LordOS",
+ "pt": "Servidor gráfico e compositor Wayland do LordOS"
+ },
+ "sub": {
+ "en": "lord-server, in C: KMS without libdrm, evdev without libinput, composition on CPU or GPU. Linux apps and isolated .lpk apps connect here as Wayland clients",
+ "es": "lord-server, en C: KMS sin libdrm, evdev sin libinput, composición en CPU o GPU. Las apps de Linux y las .lpk aisladas se conectan acá como clientes Wayland",
+ "pt": "lord-server, em C: KMS sem libdrm, evdev sem libinput, composição na CPU ou GPU. Apps Linux e apps .lpk isolados se conectam aqui como clientes Wayland"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "debian",
+ "label": {
+ "en": "Debian 13 userland",
+ "es": "Espacio de usuario de Debian 13",
+ "pt": "Espaço de usuário do Debian 13"
+ },
+ "sub": {
+ "en": "dpkg and packages, Mesa (optional GPU), PipeWire, libwayland, libxkbcommon, systemd",
+ "es": "dpkg y paquetes, Mesa (GPU opcional), PipeWire, libwayland, libxkbcommon, systemd",
+ "pt": "dpkg e pacotes, Mesa (GPU opcional), PipeWire, libwayland, libxkbcommon, systemd"
+ },
+ "tone": "reused"
+ },
+ {
+ "id": "kernel",
+ "label": {
+ "en": "Linux kernel",
+ "es": "Kernel Linux",
+ "pt": "Kernel Linux"
+ },
+ "sub": {
+ "en": "DRM/KMS, evdev, Landlock, seccomp, cgroups v2, eBPF",
+ "es": "DRM/KMS, evdev, Landlock, seccomp, cgroups v2, eBPF",
+ "pt": "DRM/KMS, evdev, Landlock, seccomp, cgroups v2, eBPF"
+ },
+ "tone": "kernel"
+ }
+ ],
+ "edges": [],
+ "caption": {
+ "en": "Violet layers are LordOS's own code; the lower layers are reused from Debian and Linux.",
+ "es": "Las capas violetas son código propio de LordOS; las de abajo se reutilizan de Debian y Linux.",
+ "pt": "As camadas violeta são código próprio do LordOS; as de baixo são reaproveitadas do Debian e do Linux."
+ }
+ },
+ {
+ "id": "processes",
+ "kind": "stack",
+ "title": {
+ "en": "Processes and privileges",
+ "es": "Procesos y privilegios",
+ "pt": "Processos e privilégios"
+ },
+ "nodes": [
+ {
+ "id": "apps",
+ "label": {
+ "en": "Sandboxed app processes",
+ "es": "Procesos de apps aisladas",
+ "pt": "Processos de apps isolados"
+ },
+ "sub": {
+ "en": "lord-server --app <id>: one per .lpk app and Passwords; Landlock, seccomp, cgroup",
+ "es": "lord-server --app <id>: uno por app .lpk y Contraseñas; Landlock, seccomp, cgroup",
+ "pt": "lord-server --app <id>: um por app .lpk e Senhas; Landlock, seccomp, cgroup"
+ },
+ "tone": "user"
+ },
+ {
+ "id": "helpers",
+ "label": {
+ "en": "Sandboxed helpers",
+ "es": "Ayudantes aislados",
+ "pt": "Ajudantes isolados"
+ },
+ "sub": {
+ "en": "lord-doc, lord-media, lord-maild, lord-vault: no sockets, no exec, files only as descriptors",
+ "es": "lord-doc, lord-media, lord-maild, lord-vault: sin sockets, sin exec, archivos solo como descriptores",
+ "pt": "lord-doc, lord-media, lord-maild, lord-vault: sem sockets, sem exec, arquivos só como descritores"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "session",
+ "label": {
+ "en": "lord-server (one per user)",
+ "es": "lord-server (uno por usuario)",
+ "pt": "lord-server (um por usuário)"
+ },
+ "sub": {
+ "en": "Runs as the user: compositor, UI engine, broker; no command execution",
+ "es": "Corre como el usuario: compositor, motor de interfaz, broker; sin ejecución de comandos",
+ "pt": "Roda como o usuário: compositor, motor de interface, broker; sem execução de comandos"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "root",
+ "label": {
+ "en": "Root services with closed interfaces",
+ "es": "Servicios root con interfaces cerradas",
+ "pt": "Serviços root com interfaces fechadas"
+ },
+ "sub": {
+ "en": "lord-sessiond, lord-netd, lord-netperm, lord-fand, and the admin helper's fixed action table",
+ "es": "lord-sessiond, lord-netd, lord-netperm, lord-fand y la tabla fija de acciones del ayudante admin",
+ "pt": "lord-sessiond, lord-netd, lord-netperm, lord-fand e a tabela fixa de ações do ajudante admin"
+ },
+ "tone": "kernel"
+ },
+ {
+ "id": "kernel",
+ "label": {
+ "en": "Linux kernel",
+ "es": "Kernel Linux",
+ "pt": "Kernel Linux"
+ },
+ "sub": {
+ "en": "Enforces Landlock, seccomp, cgroups and the firewall's eBPF programs",
+ "es": "Aplica Landlock, seccomp, cgroups y los programas eBPF del firewall",
+ "pt": "Aplica Landlock, seccomp, cgroups e os programas eBPF do firewall"
+ },
+ "tone": "kernel"
+ }
+ ],
+ "edges": [],
+ "caption": {
+ "en": "Privilege goes down the stack; each layer talks to the one below only through a narrow, validated interface.",
+ "es": "El privilegio aumenta hacia abajo; cada capa habla con la de abajo solo por una interfaz angosta y validada.",
+ "pt": "O privilégio aumenta para baixo; cada camada fala com a de baixo só por uma interface estreita e validada."
+ }
+ },
+ {
+ "id": "sessions",
+ "kind": "flow",
+ "title": {
+ "en": "Lending the display to a session",
+ "es": "Prestarle la pantalla a una sesión",
+ "pt": "Emprestar a tela a uma sessão"
+ },
+ "nodes": [
+ {
+ "id": "greeter",
+ "label": {
+ "en": "Login screen",
+ "es": "Pantalla de inicio de sesión",
+ "pt": "Tela de login"
+ },
+ "sub": {
+ "en": "Runs as lordos-greeter; only sends the request",
+ "es": "Corre como lordos-greeter; solo envía el pedido",
+ "pt": "Roda como lordos-greeter; só envia o pedido"
+ },
+ "tone": "user"
+ },
+ {
+ "id": "sessiond",
+ "label": {
+ "en": "lord-sessiond (root)",
+ "es": "lord-sessiond (root)",
+ "pt": "lord-sessiond (root)"
+ },
+ "sub": {
+ "en": "Verifies the password against /etc/shadow",
+ "es": "Verifica la contraseña contra /etc/shadow",
+ "pt": "Verifica a senha contra /etc/shadow"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "devices",
+ "label": {
+ "en": "Card and input",
+ "es": "Placa e entrada",
+ "pt": "Placa e entrada"
+ },
+ "sub": {
+ "en": "Opened as root, passed over a socket",
+ "es": "Abiertos como root, pasados por un socket",
+ "pt": "Abertos como root, passados por um socket"
+ },
+ "tone": "kernel"
+ },
+ {
+ "id": "session",
+ "label": {
+ "en": "User session",
+ "es": "Sesión del usuario",
+ "pt": "Sessão do usuário"
+ },
+ "sub": {
+ "en": "lord-server as the user, composing on GPU or CPU",
+ "es": "lord-server como el usuario, componiendo en GPU o CPU",
+ "pt": "lord-server como o usuário, compondo na GPU ou CPU"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "switch",
+ "label": {
+ "en": "Switch user",
+ "es": "Cambiar de usuario",
+ "pt": "Trocar de usuário"
+ },
+ "sub": {
+ "en": "Input revoked, display control dropped, then lent to the next",
+ "es": "Entrada revocada, control de pantalla quitado, y recién ahí se presta a la siguiente",
+ "pt": "Entrada revogada, controle da tela retirado, só então emprestado à próxima"
+ },
+ "tone": "deny"
+ }
+ ],
+ "edges": [
+ {
+ "from": "greeter",
+ "to": "sessiond",
+ "label": {
+ "en": "login request",
+ "es": "pedido de inicio",
+ "pt": "pedido de login"
+ }
+ },
+ {
+ "from": "sessiond",
+ "to": "devices",
+ "label": {
+ "en": "opens",
+ "es": "abre",
+ "pt": "abre"
+ }
+ },
+ {
+ "from": "devices",
+ "to": "session",
+ "label": {
+ "en": "lent",
+ "es": "prestados",
+ "pt": "emprestados"
+ }
+ },
+ {
+ "from": "session",
+ "to": "switch",
+ "label": {
+ "en": "on a switch",
+ "es": "al cambiar",
+ "pt": "na troca"
+ }
+ }
+ ],
+ "caption": {
+ "en": "The visible session uses the GPU without ever being root; on a switch its access is revoked before the next session gets the devices.",
+ "es": "La sesión visible usa la GPU sin ser nunca root; al cambiar, se le revoca el acceso antes de que la siguiente reciba los dispositivos.",
+ "pt": "A sessão visível usa a GPU sem nunca ser root; na troca, o acesso é revogado antes que a próxima receba os dispositivos."
+ }
+ },
+ {
+ "id": "frame",
+ "kind": "flow",
+ "title": {
+ "en": "From a mouse move to a new frame",
+ "es": "De un movimiento del mouse a un cuadro nuevo",
+ "pt": "De um movimento do mouse a um novo quadro"
+ },
+ "nodes": [
+ {
+ "id": "input",
+ "label": {
+ "en": "evdev event",
+ "es": "Evento evdev",
+ "pt": "Evento evdev"
+ },
+ "sub": {
+ "en": "From the kernel",
+ "es": "Desde el kernel",
+ "pt": "Do kernel"
+ },
+ "tone": "kernel"
+ },
+ {
+ "id": "hit",
+ "label": {
+ "en": "Hit test",
+ "es": "Búsqueda del nodo",
+ "pt": "Teste de clique"
+ },
+ "sub": {
+ "en": "Which node is under the pointer",
+ "es": "Qué nodo está bajo el puntero",
+ "pt": "Qual nó está sob o ponteiro"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "react",
+ "label": {
+ "en": "React update",
+ "es": "Actualización de React",
+ "pt": "Atualização do React"
+ },
+ "sub": {
+ "en": "Only changed nodes are marked",
+ "es": "Solo se marcan los nodos que cambiaron",
+ "pt": "Só os nós alterados são marcados"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "paint",
+ "label": {
+ "en": "Layout and paint",
+ "es": "Layout y pintado",
+ "pt": "Layout e pintura"
+ },
+ "sub": {
+ "en": "Only the damaged region",
+ "es": "Solo la región dañada",
+ "pt": "Só a região alterada"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "flip",
+ "label": {
+ "en": "Page flip",
+ "es": "Cambio de página",
+ "pt": "Troca de página"
+ },
+ "sub": {
+ "en": "On the next vblank, CPU or GPU path",
+ "es": "En el próximo vblank, por CPU o GPU",
+ "pt": "No próximo vblank, via CPU ou GPU"
+ },
+ "tone": "kernel"
+ }
+ ],
+ "edges": [
+ {
+ "from": "input",
+ "to": "hit",
+ "label": {
+ "en": "read",
+ "es": "lectura",
+ "pt": "leitura"
+ }
+ },
+ {
+ "from": "hit",
+ "to": "react",
+ "label": {
+ "en": "JS event",
+ "es": "evento JS",
+ "pt": "evento JS"
+ }
+ },
+ {
+ "from": "react",
+ "to": "paint",
+ "label": {
+ "en": "styles, children, text",
+ "es": "estilos, hijos, texto",
+ "pt": "estilos, filhos, texto"
+ }
+ },
+ {
+ "from": "paint",
+ "to": "flip",
+ "label": {
+ "en": "back buffer",
+ "es": "buffer trasero",
+ "pt": "buffer traseiro"
+ }
+ }
+ ],
+ "caption": {
+ "en": "The engine repaints only what changed, then flips the page on the next vertical blank.",
+ "es": "El motor repinta solo lo que cambió y cambia de página en el siguiente refresco vertical.",
+ "pt": "O motor repinta só o que mudou e troca a página no próximo retraço vertical."
+ }
+ },
+ {
+ "id": "permission",
+ "kind": "flow",
+ "title": {
+ "en": "How a permission request travels",
+ "es": "Cómo viaja un pedido de permiso",
+ "pt": "Como um pedido de permissão viaja"
+ },
+ "nodes": [
+ {
+ "id": "app",
+ "label": {
+ "en": "Isolated app",
+ "es": "App aislada",
+ "pt": "App isolado"
+ },
+ "sub": {
+ "en": "Asks through the broker socket",
+ "es": "Pide por el socket del broker",
+ "pt": "Pede pelo socket do broker"
+ },
+ "tone": "user"
+ },
+ {
+ "id": "broker",
+ "label": {
+ "en": "Broker in lord-server",
+ "es": "Broker en lord-server",
+ "pt": "Broker no lord-server"
+ },
+ "sub": {
+ "en": "Looks up the stored decision (perms.c)",
+ "es": "Busca la decisión guardada (perms.c)",
+ "pt": "Consulta a decisão salva (perms.c)"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "prompt",
+ "label": {
+ "en": "System prompt",
+ "es": "Aviso del sistema",
+ "pt": "Aviso do sistema"
+ },
+ "sub": {
+ "en": "Only if not decided yet; drawn by the session",
+ "es": "Solo si todavía no se decidió; lo dibuja la sesión",
+ "pt": "Só se ainda não foi decidido; desenhado pela sessão"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "user",
+ "label": {
+ "en": "You decide",
+ "es": "Vos decidís",
+ "pt": "Você decide"
+ },
+ "sub": {
+ "en": "Allow or Don't Allow, saved in permisos.json",
+ "es": "Permitir o No permitir, guardado en permisos.json",
+ "pt": "Permitir ou Não permitir, salvo em permisos.json"
+ },
+ "tone": "user"
+ },
+ {
+ "id": "enforce",
+ "label": {
+ "en": "Enforced",
+ "es": "Se aplica",
+ "pt": "Aplicado"
+ },
+ "sub": {
+ "en": "Broker checks every call; sandbox and kernel block the rest",
+ "es": "El broker revisa cada llamada; la caja de arena y el kernel bloquean el resto",
+ "pt": "O broker confere cada chamada; o sandbox e o kernel bloqueiam o resto"
+ },
+ "tone": "kernel"
+ },
+ {
+ "id": "revoke",
+ "label": {
+ "en": "Revocable",
+ "es": "Revocable",
+ "pt": "Revogável"
+ },
+ "sub": {
+ "en": "Settings → Privacy; camera and microphone stop at once",
+ "es": "Ajustes → Privacidad; cámara y micrófono se cortan al instante",
+ "pt": "Ajustes → Privacidade; câmera e microfone param na hora"
+ },
+ "tone": "allow"
+ }
+ ],
+ "edges": [
+ {
+ "from": "app",
+ "to": "broker",
+ "label": {
+ "en": "request",
+ "es": "pedido",
+ "pt": "pedido"
+ }
+ },
+ {
+ "from": "broker",
+ "to": "prompt",
+ "label": {
+ "en": "state is Ask",
+ "es": "estado Preguntar",
+ "pt": "estado Perguntar"
+ }
+ },
+ {
+ "from": "prompt",
+ "to": "user",
+ "label": {
+ "en": "shown",
+ "es": "se muestra",
+ "pt": "exibido"
+ }
+ },
+ {
+ "from": "user",
+ "to": "enforce",
+ "label": {
+ "en": "answer",
+ "es": "respuesta",
+ "pt": "resposta"
+ }
+ },
+ {
+ "from": "enforce",
+ "to": "revoke",
+ "label": {
+ "en": "later",
+ "es": "después",
+ "pt": "depois"
+ }
+ }
+ ],
+ "caption": {
+ "en": "The app never answers its own prompt: the decision is stored where it can't write, and checked in C on every request.",
+ "es": "La app nunca responde su propio aviso: la decisión se guarda donde no puede escribir y se revisa en C en cada pedido.",
+ "pt": "O app nunca responde ao próprio aviso: a decisão fica onde ele não pode escrever e é conferida em C a cada pedido."
+ }
+ },
+ {
+ "id": "firewall",
+ "kind": "flow",
+ "title": {
+ "en": "The path of a connection",
+ "es": "El camino de una conexión",
+ "pt": "O caminho de uma conexão"
+ },
+ "nodes": [
+ {
+ "id": "socket",
+ "label": {
+ "en": "App opens a connection",
+ "es": "La app abre una conexión",
+ "pt": "O app abre uma conexão"
+ },
+ "sub": {
+ "en": "connect, sendto, bind or socket",
+ "es": "connect, sendto, bind o socket",
+ "pt": "connect, sendto, bind ou socket"
+ },
+ "tone": "user"
+ },
+ {
+ "id": "hook",
+ "label": {
+ "en": "cgroup eBPF hook",
+ "es": "Gancho eBPF de cgroup",
+ "pt": "Gancho eBPF de cgroup"
+ },
+ "sub": {
+ "en": "In the kernel; finds the app by its scope",
+ "es": "En el kernel; reconoce la app por su scope",
+ "pt": "No kernel; reconhece o app pelo escopo"
+ },
+ "tone": "kernel"
+ },
+ {
+ "id": "rule",
+ "label": {
+ "en": "Per-app rules",
+ "es": "Reglas por app",
+ "pt": "Regras por app"
+ },
+ "sub": {
+ "en": "Restrictions, then the most specific rule, then trusted, then mode",
+ "es": "Restricciones, luego la regla más específica, luego confianza, luego el modo",
+ "pt": "Restrições, depois a regra mais específica, depois confiança, depois o modo"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "verdict",
+ "label": {
+ "en": "Allow or deny",
+ "es": "Permitir o denegar",
+ "pt": "Permitir ou negar"
+ },
+ "sub": {
+ "en": "Denied: the app gets EPERM",
+ "es": "Denegada: la app recibe EPERM",
+ "pt": "Negada: o app recebe EPERM"
+ },
+ "tone": "deny"
+ },
+ {
+ "id": "monitor",
+ "label": {
+ "en": "Monitor map",
+ "es": "Mapa del Monitor",
+ "pt": "Mapa do Monitor"
+ },
+ "sub": {
+ "en": "New connections and counters, once per second",
+ "es": "Conexiones nuevas y contadores, una vez por segundo",
+ "pt": "Conexões novas e contadores, uma vez por segundo"
+ },
+ "tone": "ours"
+ }
+ ],
+ "edges": [
+ {
+ "from": "socket",
+ "to": "hook",
+ "label": {
+ "en": "system call",
+ "es": "llamada al sistema",
+ "pt": "chamada de sistema"
+ }
+ },
+ {
+ "from": "hook",
+ "to": "rule",
+ "label": {
+ "en": "map lookup",
+ "es": "búsqueda en el mapa",
+ "pt": "consulta ao mapa"
+ }
+ },
+ {
+ "from": "rule",
+ "to": "verdict",
+ "label": {
+ "en": "decision",
+ "es": "decisión",
+ "pt": "decisão"
+ }
+ },
+ {
+ "from": "verdict",
+ "to": "monitor",
+ "label": {
+ "en": "ring buffer",
+ "es": "anillo de eventos",
+ "pt": "anel de eventos"
+ }
+ }
+ ],
+ "caption": {
+ "en": "The decision happens in the kernel when the connection opens; nothing runs per packet.",
+ "es": "La decisión ocurre en el kernel cuando se abre la conexión; nada corre por cada paquete.",
+ "pt": "A decisão acontece no kernel quando a conexão abre; nada roda por pacote."
+ }
+ },
+ {
+ "id": "helpers",
+ "kind": "flow",
+ "title": {
+ "en": "Opening an untrusted file",
+ "es": "Abrir un archivo no confiable",
+ "pt": "Abrir um arquivo não confiável"
+ },
+ "nodes": [
+ {
+ "id": "app",
+ "label": {
+ "en": "App asks to open a file",
+ "es": "La app pide abrir un archivo",
+ "pt": "O app pede para abrir um arquivo"
+ },
+ "sub": {
+ "en": "PDF, archive, video, photo, mail",
+ "es": "PDF, archivo comprimido, video, foto, correo",
+ "pt": "PDF, arquivo compactado, vídeo, foto, e-mail"
+ },
+ "tone": "user"
+ },
+ {
+ "id": "server",
+ "label": {
+ "en": "lord-server",
+ "es": "lord-server",
+ "pt": "lord-server"
+ },
+ "sub": {
+ "en": "Validates the path and opens the file",
+ "es": "Valida la ruta y abre el archivo",
+ "pt": "Valida o caminho e abre o arquivo"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "helper",
+ "label": {
+ "en": "Sandboxed helper",
+ "es": "Ayudante aislado",
+ "pt": "Ajudante isolado"
+ },
+ "sub": {
+ "en": "Parses with FFmpeg, Poppler, libarchive or OpenSSL; no network, no exec",
+ "es": "Lee con FFmpeg, Poppler, libarchive u OpenSSL; sin red, sin exec",
+ "pt": "Lê com FFmpeg, Poppler, libarchive ou OpenSSL; sem rede, sem exec"
+ },
+ "tone": "reused"
+ },
+ {
+ "id": "result",
+ "label": {
+ "en": "Sealed shared memory",
+ "es": "Memoria compartida sellada",
+ "pt": "Memória compartilhada selada"
+ },
+ "sub": {
+ "en": "Pixels or pages, validated by lord-server",
+ "es": "Píxeles o páginas, validados por lord-server",
+ "pt": "Pixels ou páginas, validados pelo lord-server"
+ },
+ "tone": "allow"
+ }
+ ],
+ "edges": [
+ {
+ "from": "app",
+ "to": "server",
+ "label": {
+ "en": "request",
+ "es": "pedido",
+ "pt": "pedido"
+ }
+ },
+ {
+ "from": "server",
+ "to": "helper",
+ "label": {
+ "en": "file descriptor",
+ "es": "descriptor de archivo",
+ "pt": "descritor de arquivo"
+ }
+ },
+ {
+ "from": "helper",
+ "to": "result",
+ "label": {
+ "en": "sealed memfd",
+ "es": "memfd sellado",
+ "pt": "memfd selado"
+ }
+ }
+ ],
+ "caption": {
+ "en": "A malicious file can crash its helper, but the helper can't reach the network, run programs or open other files.",
+ "es": "Un archivo malicioso puede tirar abajo su ayudante, pero el ayudante no puede llegar a la red, correr programas ni abrir otros archivos.",
+ "pt": "Um arquivo malicioso pode derrubar o ajudante, mas o ajudante não alcança a rede, não roda programas nem abre outros arquivos."
+ }
+ }
+ ]
+}
\ No newline at end of file
diff --git a/web/content/paper/meta.json b/web/content/paper/meta.json
new file mode 100644
index 0000000..4cead93
--- /dev/null
+++ b/web/content/paper/meta.json
@@ -0,0 +1,19 @@
+{
+ "title": {
+ "en": "LordOS: a private, fast GNU/Linux desktop built on Debian and Wayland",
+ "es": "LordOS: un escritorio GNU/Linux privado y rápido, construido sobre Debian y Wayland",
+ "pt": "LordOS: um desktop GNU/Linux privado e rápido, construído sobre Debian e Wayland"
+ },
+ "subtitle": {
+ "en": "Technical whitepaper: design, security model and current state",
+ "es": "Documento técnico: diseño, modelo de seguridad y estado actual",
+ "pt": "Documento técnico: projeto, modelo de segurança e estado atual"
+ },
+ "version": "0.7.0 Beta",
+ "date": "2026-10-18",
+ "authors": [
+ "Pablo Miranda",
+ "Federico Pereira"
+ ],
+ "org": "IPERFEX"
+}
\ No newline at end of file
diff --git a/web/content/paper/paper.en.md b/web/content/paper/paper.en.md
new file mode 100644
index 0000000..33943cf
--- /dev/null
+++ b/web/content/paper/paper.en.md
@@ -0,0 +1,534 @@
+## Abstract
+
+LordOS is a free GNU/Linux distribution based on Debian 13 that ships a desktop environment of its own, built from its fundamental components on top of Debian and Wayland. Instead of GNOME or KDE, it has its own display server and Wayland compositor written in C (`lord-server`), its own user-interface engine (React running on the QuickJS JavaScript engine, with layout, painting and text in native C code), its own native apps, and its own security services: an app sandbox launcher, a permission broker, a per-app permission store, a kernel-enforced per-app firewall, package signing and an encrypted password vault. It reuses what is mature and widely reviewed: the Linux kernel, Debian and its packages, Mesa, PipeWire, the Wayland protocol, and a handful of libraries (FFmpeg, Poppler, libarchive, OpenSSL, Monocypher) that are confined to small sandboxed helper processes.
+
+This paper describes the design and the current state of version **0.7.0 Beta** (October 2026) for a technical reader who wants to check the project rather than take it on trust. Every claim refers to a file in the public repository. Numbers are the ones measured in the project's test logs, and are labelled with where they were measured. Things that are designed but not built are marked as such.
+
+## 1. Vision
+
+### 1.1 The problem
+
+A modern Linux desktop is assembled from many independent projects: a display server or compositor, a toolkit, a session manager, a settings daemon, a keyring, a network manager, a firewall front end, and the apps. Each is good on its own terms, but the seams between them are where things get slow, inconsistent or insecure. Three seams in particular motivated LordOS:
+
+- **Weight.** A desktop that draws its shell with a web engine, or loads several toolkits at once, needs hundreds of megabytes before the user opens anything. LordOS wants to be comfortable on modest machines and on a Raspberry Pi 5.
+- **Trust in apps.** On a traditional Linux desktop, every program the user runs can read the whole home folder, record the microphone, open any network connection and read the clipboard. Sandboxing exists, but it is usually an add-on that the desktop itself doesn't understand.
+- **Visibility.** Users rarely see which app is talking to which server, and even more rarely can they say "this app may not use the internet" in a way the app can't get around.
+
+### 1.2 Principles
+
+The project follows a short list of rules, written down in `AGENTS.md` and `docs/ARCHITECTURE.md`:
+
+1. **Own the parts the user touches; reuse the foundations.** The display server, the compositor, the UI engine, the apps and the security services are LordOS's code. The kernel, Debian's packages, Mesa, PipeWire and the Wayland protocol are reused.
+2. **A strict dependency policy.** X11, wlroots, libdrm, libinput, WebKit, GTK and Qt are not used inside LordOS. Libraries that parse untrusted data are linked only by sandboxed helpers, never by the compositor.
+3. **The interface can't run commands.** JavaScript in LordOS has no API to execute arbitrary programs. There are three narrow, argument-free exceptions (the Terminal's login shell, launching an installed `.desktop` app, and starting an installed `.lpk` app in its sandbox).
+4. **Root only through closed doors.** Everything that needs root goes through a fixed table of validated actions or a small dedicated service with a closed protocol.
+5. **The CPU path must always work.** GPU composition is an optimization, never a requirement.
+6. **The compositor never waits.** Helpers, apps and services talk to `lord-server` over non-blocking sockets; a hung app hangs only itself.
+7. **Verify on a real system.** Every milestone is checked on a virtual machine with real screenshots before it is marked done, and compatibility that wasn't tested isn't claimed.
+
+### Source files
+
+- [AGENTS.md](https://github.com/lordbasex/LordOS/blob/main/AGENTS.md)
+- [docs/ARCHITECTURE.md](https://github.com/lordbasex/LordOS/blob/main/docs/ARCHITECTURE.md)
+
+## 2. Architecture
+
+### 2.1 Layers
+
+[[diagram:layers]]
+
+From the bottom up:
+
+- **The Linux kernel** provides DRM/KMS for displays, evdev for input, and the security features LordOS builds on: Landlock, seccomp-bpf, cgroups v2 and eBPF. On PCs it is Debian's kernel; on the Raspberry Pi 5 it is LordOS's build of the Raspberry Pi kernel with Landlock enabled (§7.4).
+- **Debian 13** provides the userland: `dpkg` and the package archive, systemd, Mesa, PipeWire, `libwayland`, `libxkbcommon`, CUPS, BlueZ and the rest.
+- **`lord-server`** is the display server and Wayland compositor. It drives displays and input directly, composites, and serves the Wayland protocol to Linux apps.
+- **The UI engine** lives inside `lord-server`: QuickJS runs the React interface, and native C code does layout, painting and text.
+- **Apps** come in three kinds: built-in apps and the theme, which run in `lord-server`'s JavaScript context; installed `.lpk` apps, each in its own sandboxed process with its own engine instance; and Linux apps, which connect to the compositor as ordinary Wayland clients.
+
+### 2.2 Processes and privileges
+
+[[diagram:processes]]
+
+A running LordOS system has a small number of processes with clearly separated roles:
+
+| Process | Runs as | Role |
+|---|---|---|
+| `lord-sessiond` | root | login screen, sessions, lending the display and input to the visible session, remote desktop |
+| `lord-netd` | root | the system network: DHCP, Wi-Fi, VPN; only the `net-*` actions |
+| `lord-netperm` | root (limited capabilities) | per-app network rules, enforced with cgroup eBPF |
+| `lord-fand` | root (no capabilities) | fan control by temperature |
+| `lord-server` | the user | one per session: compositor, UI engine, broker |
+| `lord-server --app <id>` | the user, sandboxed | one per running `.lpk` app (and Passwords) |
+| `lord-doc`, `lord-media`, `lord-maild`, `lord-vault` | the user, sandboxed | helpers that process untrusted data or secrets |
+| login screen | `lordos-greeter` | draws the login UI; never verifies passwords itself |
+
+Each root process has a narrow, documented interface. §6.3 describes them.
+
+### 2.3 What is ours and what is reused
+
+| Ours (in this repository) | Reused |
+|---|---|
+| Display server and Wayland compositor (C) | Linux kernel |
+| UI engine: native nodes, flexbox layout, rasterizer, text shaping, bidi, input methods | Debian 13 and its packages; `dpkg` |
+| React renderer (host configuration for `react-reconciler`) | React 19.3.1, `react-reconciler` 0.34 (bundled in the theme) |
+| Native apps and themes | QuickJS 2025-04-26 (vendored) |
+| Sandbox, broker, permissions, signing, firewall service, vault | Mesa (optional), PipeWire, `libwayland`, `libxkbcommon` |
+| Session manager, network service, fan service | systemd, systemd-resolved, BlueZ, CUPS, wpa_supplicant, OpenVPN, strongSwan's daemon |
+| Debian package engine (OpenPGP, xz, HTTP, resolver) | FFmpeg, Poppler, libarchive, OpenSSL, Monocypher (in helpers only) |
+| Touchpad driver, terminal emulator, WebAssembly interpreter | stb (fonts and images), fonts under the OFL |
+
+LordOS speaks to several Debian services over their own protocols with its own clients: D-Bus (BlueZ, power profiles, time and date), IPP (CUPS), the PulseAudio protocol (PipeWire), and the Secret Service. libdbus, sd-bus, libcups, libpulse, libbpf and libapt are not used.
+
+### 2.4 System services
+
+- **Network (`lord-netd`).** The network belongs to the system, not to a session. `lord-sessiond` starts `lord-netd` at boot with a fixed path and no arguments, so the machine has an address before anyone logs in. It runs only the closed `net-*` actions: its own DHCP client and netlink code, Wi-Fi through Debian's `wpa_supplicant`, WireGuard through LordOS's own netlink code, OpenVPN, IPsec/IKEv2 through strongSwan's `charon` driven over VICI with LordOS's own client, and optionally OpenConnect, PPTP and Fortinet-compatible tunnels. It talks only to the sessions' root helpers, over a socket that accepts only uid 0.
+- **Fans (`lord-fand`).** A root service that reads the CPU temperature every 2 s and writes fan duty from a profile, from early boot. It drives only fans its own scan found: the Raspberry Pi 5 fan header and allow-listed motherboard controllers. Laptop, GPU and unknown fans are never written. On stop, or after a crash, it restores the original kernel settings. It runs no programs, has no network, no capabilities and no device nodes.
+- **Hardware settings.** Displays (modes from KMS with EDID names, a 15-second "keep these settings?" revert, per-display persistence, rotation, Night Light), Bluetooth through BlueZ, battery and power profiles, idle and lid handling, date and time, notifications for Linux apps and default apps. Changes arrive as kernel uevents and D-Bus signals; nothing polls.
+
+### Source files
+
+- [server/src/main.c](https://github.com/lordbasex/LordOS/blob/main/server/src/main.c)
+- [server/src/admin.c](https://github.com/lordbasex/LordOS/blob/main/server/src/admin.c)
+- [server/src/net/netd.c](https://github.com/lordbasex/LordOS/blob/main/server/src/net/netd.c)
+- [server/src/fan/fand.c](https://github.com/lordbasex/LordOS/blob/main/server/src/fan/fand.c)
+- [server/src/hw](https://github.com/lordbasex/LordOS/tree/main/server/src/hw)
+
+## 3. The compositor
+
+### 3.1 Displays without libdrm
+
+`lord-server` sets display modes with the kernel's DRM ioctls directly (`kms.c`): it enumerates connectors, CRTCs and planes, allocates buffers, and page-flips on vertical blank. It picks the card that has connectors, not simply `card0`, which matters on boards where the display controller and the GPU are separate devices (on the Raspberry Pi 5, `vc4` and `v3d`).
+
+### 3.2 Two ways to build a frame
+
+- **CPU path.** The UI and app windows are copied into a canvas, and a "dumb" buffer is presented with a page flip. It needs nothing but the kernel. It is the default when there is no 3D-capable card, and `LORD_GPU=0` forces it (the boot menu's safe mode uses it).
+- **GPU path.** Mesa's GBM, EGL and GLES2 (`server/src/gpu/gpu.c`). The UI becomes one texture, and only the changed region is uploaded each frame. App windows are not copied into the UI canvas: the UI leaves a transparent hole where each window goes, and window textures are drawn underneath, so an app that only changes its own content doesn't cause a UI repaint. Apps can hand over GPU buffers (`linux-dmabuf`) with no copies, and a fullscreen app with a suitable buffer is scanned out directly. The cursor uses the hardware cursor plane.
+
+The path is chosen at start-up: a card without 3D (simpledrm, bochs, virtio-gpu without virgl, and others) uses the CPU without even loading Mesa; a software OpenGL renderer also falls back to the CPU, because composing with it costs more than LordOS's own CPU path. If a GPU frame fails, the GPU is turned off and the CPU path takes over.
+
+**Status:** the GPU path was exercised with Mesa's software renderer in virtual machines. Testing on real AMD and Nvidia cards is pending.
+
+### 3.3 Windows and input
+
+- **Window management in C.** Moving and resizing run in C with one event per frame and no JavaScript, and a window being moved is drawn from its own layer. All four edges and corners resize, with LordOS's own cursors.
+- **Input without libinput.** Keyboards, mice and tablets are read from evdev. Keyboard layouts come from `libxkbcommon` (every XKB layout, variants and compose).
+- **Touchpad and touchscreen.** LordOS has its own multitouch driver (`server/src/tp`): pointer acceleration, tap and two-finger click, palm rejection, kinetic and natural scrolling, pinch, and three-finger swipes. Gestures reach both the LordOS interface and Linux apps (`zwp_pointer_gestures_v1`). It is tested with recorded gestures in `make test`.
+
+### 3.4 Wayland compatibility
+
+The compositor (`server/src/wl/wl.c`) uses only `libwayland-server` and code generated from the protocol XML. It offers: `wl_compositor`, `wl_subcompositor`, `wl_shm`, `wl_output` (one per display), `xdg_wm_base` with popups, `wl_seat` (pointer, keyboard, touch), `wl_data_device_manager` (a clipboard shared with LordOS), `zxdg_decoration_manager_v1`, the KDE server-decoration protocol (so GTK 3 apps such as Firefox get the theme's frame), `zxdg_output_manager_v1`, `wp_fractional_scale_v1`, `wp_viewporter`, `zwp_linux_dmabuf_v1` v4, `wp_presentation`, `zwp_relative_pointer_manager_v1`, `zwp_pointer_constraints_v1`, `zwp_pointer_gestures_v1` and `wp_cursor_shape_manager_v1`.
+
+Linux windows enter the SDK's window manager like any other, with title, focus, maximize, minimize and a Dock icon. Apps that ask for server-side decoration get the theme's frame; apps that draw their own (GTK 4) keep it, and their shadow is clipped. GTK 4 and libadwaita apps follow light/dark mode, the accent and the button order through an `org.freedesktop.portal.Settings` implementation that `lord-server` serves itself on the session bus; GTK 3 follows through the GSettings keyfile.
+
+**Xwayland is not supported**: LordOS doesn't run X11-only apps. Also pending: drag and drop, the primary selection, LordOS input methods inside Linux apps (`text-input`), activation (`xdg-activation`), explicit sync and SVG app icons. No screen-capture protocol is offered to apps.
+
+### 3.5 Several displays and HiDPI
+
+Every connected display is driven at once, extended or mirrored, in one logical space, with an arrangement remembered by EDID identity and hotplug handling. Each display is painted at its own scale (100, 125, 150, 175 or 200 %), so text and vectors are rasterized at its real resolution. Linux apps get one `wl_output` per display and fractional scaling. Tested with two virtual heads (1280×800 and 2560×1600) on both paths; real monitors, laptop panels and DisplayPort hubs are untested.
+
+### 3.6 Sessions and login
+
+[[diagram:sessions]]
+
+`lord-sessiond` is LordOS's own session manager:
+
+- **The login screen** is a `lord-server` running as the unprivileged `lordos-greeter` user, with a special theme. It sends login requests to `lord-sessiond`; **passwords are always verified by the root process** against `/etc/shadow`, never by the greeter's JavaScript. Failed attempts wait 1, 2, 4… seconds, up to 5 minutes.
+- **One session per user**, all able to live at once (fast user switching). Each is a `lord-server` that starts as root and drops privileges right away.
+- **Display lending.** `lord-sessiond` opens the graphics card and the input devices as root and lends them to the session that is on the monitor, over a Unix socket. On a switch it revokes them: `EVIOCREVOKE` makes the old session's input file descriptors stop working, and `DROP_MASTER` takes display control away, before anything is given to the next session. The visible session keeps composing on the GPU without ever being root. A session off the monitor draws in memory, and only if someone is watching it remotely.
+- **Locking really takes the session off the monitor**; it is not a layer drawn on top. If the user's session hangs, the login screen still works.
+
+**Remote desktop.** The same service offers the desktop to a browser on the local network at `https://<address>:5673` (5673 spells "LORD" on a phone keypad). It is **off by default** and is turned on in Settings → Sharing. It uses TLS 1.2 or later with a self-signed P-256 certificate whose fingerprint Settings shows for comparison, a strict content security policy, same-origin checks, per-IP waits on failed logins, and a session cookie that is `Secure`, `HttpOnly` and `SameSite=Strict`. The login page never lists user accounts. The process that serves a connection drops root as soon as it knows whose session it is. Screen updates are sent as PNG when still and JPEG while moving. Audio is designed but not built. Internet access is not intended; a VPN is recommended.
+
+### Source files
+
+- [server/src/kms.c](https://github.com/lordbasex/LordOS/blob/main/server/src/kms.c), [server/src/gpu/gpu.c](https://github.com/lordbasex/LordOS/blob/main/server/src/gpu/gpu.c), [server/src/outputs.c](https://github.com/lordbasex/LordOS/blob/main/server/src/outputs.c)
+- [server/src/input.c](https://github.com/lordbasex/LordOS/blob/main/server/src/input.c), [server/src/tp](https://github.com/lordbasex/LordOS/tree/main/server/src/tp), [server/src/ui/grab.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/grab.c)
+- [server/src/wl/wl.c](https://github.com/lordbasex/LordOS/blob/main/server/src/wl/wl.c), [server/src/ui/portal.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/portal.c)
+- [server/src/remote/sessiond.c](https://github.com/lordbasex/LordOS/blob/main/server/src/remote/sessiond.c), [server/src/remote/monitor.c](https://github.com/lordbasex/LordOS/blob/main/server/src/remote/monitor.c), [server/src/remote/sess.c](https://github.com/lordbasex/LordOS/blob/main/server/src/remote/sess.c)
+
+## 4. The UI engine
+
+### 4.1 Not a browser
+
+LordOS's interface is written in JavaScript with React, but there is no web engine underneath. WebKit or Chromium would cost 100 to 300 MB of RAM per process and would not be LordOS's code. Instead, the theme and the apps use a React renderer (`runtime/index.js`) that creates and updates **native nodes** in C: `View`, `Text`, `Image`, plus surfaces for Wayland windows and media. Styles are a subset of CSS (flexbox, colours, rounded and per-side borders, shadows, blur, transforms, transitions) applied by C code that the project controls. The model is close to how a mobile framework renders React to native views, except that the "native" side here is LordOS's own.
+
+### 4.2 Pieces
+
+- **JavaScript:** QuickJS 2025-04-26, a small ES2023 engine in C, vendored as source and embedded in `lord-server`.
+- **React:** React 19.3.1 with `react-reconciler` 0.34, bundled with esbuild into each theme. The default theme with every app weighs 367 KB.
+- **Layout:** LordOS's own flexbox implementation (`layout.c`), with wrapping, logical start/end edges and right-to-left mirroring.
+- **Painting:** LordOS's own 2D rasterizer with antialiased rounded rectangles, cached shadows, reduced-resolution blur and damage tracking: only the changed region is repainted. On ARM, optional NEON loops speed up blits and masks, verified bit-identical to the C code.
+- **Text:** glyphs are rasterized with `stb_truetype`. Shaping is LordOS's own OpenType code (GSUB substitutions and GPOS positioning, colour emoji), with full Unicode bidi, Arabic joining, Indic shaping and the Universal Shaping Engine (409 of 409 test sentences identical to HarfBuzz in `tests/hb_compare.py`), CJK line breaking, Thai word breaking, and per-script font fallback. HarfBuzz, FreeType, fontconfig, fribidi and ICU are not linked by `lord-server`.
+- **Input methods:** Korean (hangul), Japanese (kana and SKK) and Chinese (pinyin), in `server/src/ime.c`, with no ibus or fcitx.
+
+[[diagram:frame]]
+
+### 4.3 How JavaScript reaches the system
+
+The JavaScript side calls native services through `lord.*` APIs implemented in C (`server/src/ui/js_*.c`): `lord.fs` (files), `lord.settings`, `lord.net`, `lord.pkg`, `lord.media`, `lord.mail`, `lord.vault`, `lord.fw`, `lord.monitor`, `lord.fan` and others. Every call validates its arguments in C. The rules are strict:
+
+- `lord-server` runs without root, and **no API executes arbitrary commands**.
+- `lord.fs` writes only in the home folder and the user's own mounts, has no general "delete" (only moving to the Trash), and refuses the folders the system reads to launch or install something or that store security decisions: `~/.local/share/applications`, `~/.config/autostart`, the installed app folder, `settings.json`, the permissions file, the firewall rules, the mail accounts file and the vault folder.
+- Anything that needs root goes through `admin.c`: a closed table of actions with arguments validated on the root side, fixed program paths and configuration generated by LordOS, never user text passed to a shell. Passwords go through standard input, never on a command line.
+- Long work never blocks a frame: helpers and services are polled from the main loop without waiting.
+
+### 4.4 Languages
+
+The interface ships in English (the default), Spanish and Portuguese, and more languages are added as language packs without code changes. Text goes through the SDK's `t('namespace.key')`, with plurals and locale formats. The whole interface mirrors for right-to-left languages, and the region (`LANG`/`LC_*`) is passed to Linux apps. `node tools/i18n-check.mjs` checks that every key exists in every language and that no third-party brand names appear in the interface.
+
+### Source files
+
+- [runtime/index.js](https://github.com/lordbasex/LordOS/blob/main/runtime/index.js), [sdk/index.js](https://github.com/lordbasex/LordOS/blob/main/sdk/index.js)
+- [server/src/ui/js.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/js.c), [server/src/ui/node.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/node.c), [server/src/ui/layout.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/layout.c), [server/src/ui/paint.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/paint.c)
+- [server/src/ui/shape.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/shape.c), [server/src/ui/otf.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/otf.c), [server/src/ui/bidi.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/bidi.c), [server/src/ime.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ime.c)
+- [server/src/ui/js_sys.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/js_sys.c), [server/src/fsops.c](https://github.com/lordbasex/LordOS/blob/main/server/src/fsops.c)
+
+## 5. Applications
+
+### 5.1 Native apps
+
+Around thirty native apps ship with LordOS, all React apps on the same engine and SDK: Files, Settings, Terminal, Store, Text Editor, Notes, Calculator, Monitor, PDF Viewer, Fonts, Emoji & Symbols, Scanner, Photos, Player, Screenshots, Camera, Recorder, Passwords, Disks, Backups, Logs, Clock, Help, Mail, Calendar, Contacts, Reminders, About and the installer. Some highlights:
+
+- **Terminal:** LordOS's own xterm-compatible emulator in C, with tabs, split panes, profiles, inline images and Sixel, and sessions that survive a restart of `lord-server`.
+- **Monitor:** CPU, memory, disks, processes, cooling and per-app network connections on a world map, with country lookup from a local database. Its sampling thread exists only while the app is open.
+- **Disks:** LordOS's own SMART reader, formatting, and bootable USB sticks verified with SHA-256.
+- **Backups:** hard-link snapshots with optional encryption, running at low priority.
+
+### 5.2 Installable `.lpk` apps
+
+Third-party native apps are packaged as `.lpk`: a gzip-compressed tar with a manifest, the bundled `app.js`, a required icon, optional translations and assets. An app doesn't carry React or the SDK; it uses the system's, which keeps it small (the example Fractal app weighs 5 KB). They install without root into `~/.local/share/lordos/apps/<id>/`. The installer rejects links, devices, absolute paths, `..`, odd characters, more than 2,000 files or 64 MB, and replaces the previous version atomically. Each one runs isolated (§6.4).
+
+### 5.3 The Store and Debian packages
+
+The Store shows Debian's apps by category with search, `.lpk` apps and local `.deb` files, and always shows a plan before installing or removing. Debian packages are handled by **LordOS's own package engine** (`server/src/pkg`): it reads the apt sources, verifies `InRelease` signatures with its own OpenPGP code (RSA and Ed25519), refuses expired, replayed, wrong-suite or trailing-data indexes, checks every index and `.deb` against SHA-256 values from the signed index, and resolves dependencies (plans identical to apt's in 12 test cases). Only the last step is Debian's: `dpkg` unpacks and configures, and remains the only writer of its database, so `apt` keeps working. LordOS has no TLS client of its own, so `https://` sources are fetched over `http://`; integrity rests on the signatures and hashes, but the package names downloaded are visible on the network.
+
+### 5.4 Linux apps
+
+Linux apps with a `.desktop` file appear in the app launcher. Launching goes through `lord.apps.launch(id)`: the interface can only name an installed `.desktop` file; `lord-server` re-reads it, checks it, builds `argv` from its `Exec` line by the specification and runs it with `execve`, without a shell or caller arguments, inside its own root-owned cgroup scope. Chromium and Firefox are preinstalled in the ISO and were verified with the LordOS frame. **Linux apps are not sandboxed by LordOS**; they get attribution and the per-app firewall (§6.6).
+
+### 5.5 WebAssembly
+
+LordOS includes its own WebAssembly interpreter in C (`server/src/wasm`), exposed as the standard `WebAssembly` global, so a native app can carry modules compiled from C, C++, Rust or Zig. It covers WebAssembly 2.0 without SIMD (the MVP plus sign extension, saturating conversions, multi-value, bulk memory and reference types), passes 26,290 of 26,290 assertions of the official test suite on the VM, and turns every error into a trap rather than a crash. On the project's example it ran 3 to 5 times faster than the same code in JavaScript.
+
+### 5.6 Installing LordOS
+
+- **Live ISO** for 64-bit PCs, with a graphical installer (UEFI and BIOS).
+- **Raspberry Pi 5 image** for SD card or NVMe (§7.4).
+- **On an existing Debian 13**: `curl -fsSL https://lordos.org/install.sh | sh`. The script asks before changing anything, downloads `SHA256SUMS` and verifies its Ed25519 signature with the release key embedded in the script, refuses to continue without a valid signature, checks the `.deb`'s SHA-256, installs it with apt and sets the system up like the ISO. The repository is private until the first public beta, so the download path is not public yet.
+
+### Source files
+
+- [apps](https://github.com/lordbasex/LordOS/tree/main/apps), [server/src/lpk.c](https://github.com/lordbasex/LordOS/blob/main/server/src/lpk.c), [tools/lpk.mjs](https://github.com/lordbasex/LordOS/blob/main/tools/lpk.mjs)
+- [server/src/pkg](https://github.com/lordbasex/LordOS/tree/main/server/src/pkg), [server/src/apps.c](https://github.com/lordbasex/LordOS/blob/main/server/src/apps.c)
+- [server/src/wasm/wasm.c](https://github.com/lordbasex/LordOS/blob/main/server/src/wasm/wasm.c), [server/src/ui/js_wasm.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/js_wasm.c)
+- [tools/install/install.sh](https://github.com/lordbasex/LordOS/blob/main/tools/install/install.sh)
+
+## 6. Security
+
+### 6.1 Threat model
+
+LordOS is designed against these threats:
+
+- **A malicious or compromised installed app** that wants the user's files, keys, microphone, camera, clipboard or network.
+- **Malicious documents and messages**: PDFs, archives, fonts, images, video and mail crafted to exploit a parser.
+- **A Linux app that wants to send data out**, or to escape the rules set for it.
+- **An attacker on the local network** trying to use the remote desktop or to tamper with downloads.
+- **Tampered packages and releases.**
+
+Outside the model, for now: a compromised kernel or root account; physical attacks; side channels; and Linux apps reading the user's files (they run as the user, as on any Debian system). Linux apps are confined only on the network.
+
+### 6.2 Least privilege
+
+- `lord-server` runs as the user. In a managed session it never holds the display or input devices itself: `lord-sessiond` lends them and revokes them.
+- Libraries that parse untrusted data are linked only by helpers: FFmpeg and libva by `lord-media`; Poppler and libarchive by `lord-doc`; OpenSSL by `lord-maild` and `lord-sessiond`; Monocypher by `lord-vault`.
+- Helpers receive files and devices as file descriptors opened by `lord-server`; they never open paths.
+- The compositor never waits for a helper or an app, so a crash or a hang stays contained.
+
+### 6.3 The root processes and their closed interfaces
+
+| Process | Accepts | Never does |
+|---|---|---|
+| `admin.c` helper | a fixed table of actions, arguments validated as root | generic actions, user text in a shell |
+| `lord-sessiond` | login requests from the greeter; short session JSON (≤ 4 KB) | let the greeter verify passwords; read pixels as root |
+| its cgroup placement child | `enter <scope> <limits>` for the calling process only, from a session's `server` leaf, running a binary from `lord-server`'s directory | place arbitrary processes; hand the tree back to the user |
+| `lord-netd` | `net-*` actions from root peers only | non-network actions; run anything from a session |
+| `lord-netperm` | `RELOAD` with no data | run programs; take arguments; open internet sockets |
+| `lord-fand` | `STATUS` for anyone; `PROFILE`, `CURVE`, `FORCE` for administrators | name paths or devices; run programs; use the network |
+
+### 6.4 The app sandbox
+
+Each `.lpk` app, and the Passwords app, runs as `lord-server --app <id>`: the same binary in "app mode", launched by `lord-server` with a validated package id as its only argument. The process connects to the compositor as a Wayland client and opens the broker socket, then applies the sandbox, and only then loads the app's code (`server/src/sec/sandbox.c`):
+
+- **Landlock** (ABI up to 6): read-only access to the package, the shared app runtime, fonts and libraries; read-write only to `~/.local/share/lordos/appdata/<id>`; scoping of abstract Unix sockets and signals.
+- **seccomp-bpf**: an allow list of system calls on every thread (TSYNC), without `ptrace`, `mount`, `kexec`, `bpf`, `perf_event_open`, `keyctl`, module loading or `execve`. New Unix sockets and `socketpair` are refused, because Landlock up to ABI 6 doesn't filter `connect` to named Unix sockets; this keeps the app away from the session bus, the print service and the Wayland socket.
+- **No privileges**: `no_new_privs`, an empty capability set and a dropped bounding set.
+- **cgroup v2**: `app-lordos-lpk-<id>.scope`, created by root, with `memory.high` 192 MB, `memory.max` 512 MB and one CPU core.
+- **Network**: without the `network` permission (declared **and** allowed), seccomp refuses internet sockets and Landlock refuses TCP connect and bind. Network namespaces are not used, because creating one needs privileges `lord-server` doesn't have.
+
+If a kernel feature is missing, the app still starts and the log says which part is missing. The deliberately malicious test app (`tests/lpk-evil`) fails at everything it tries; `build/sandbox-test` passes 14 of 14 checks for apps and 14 of 14 with network. Measured on a VM: about 13.7 MB of RSS per isolated app, a median start of 106 ms, and 0.89 ms to apply the sandbox.
+
+### 6.5 The broker, permissions and the file dialog
+
+[[diagram:permission]]
+
+The isolated app talks to `lord-server` only over one `SOCK_SEQPACKET` socket. Every request is checked in C: file access only inside the app's own data folder; clipboard reads only with the `clipboard` permission; permission requests answered from the stored decision or, if none, by a **system-drawn prompt** (*Allow / Don't Allow*); camera and microphone only through `lord-server`.
+
+- **Decisions** are stored per user in `~/.config/lordos/permisos.json`, outside the app's reach. The lookup is O(1).
+- **The file dialog is LordOS's own powerbox** (`sdk/powerbox.jsx`), not `xdg-desktop-portal`: `lord-server` draws it, opens the chosen file and passes only that descriptor. The only desktop portal interface LordOS implements is `org.freedesktop.portal.Settings`, for GTK theming.
+- **Microphone:** `lord-server` owns the PipeWire stream and gives the app a read-only shared ring.
+- **Camera:** `lord-server` opens the device and gives it only to `lord-media`; the app gets a read-only view of the decoded frames and must acknowledge each one, and `lord-server` validates every acknowledgement.
+- **Revocation:** denying the camera or the microphone in Settings stops it at once (the app's `lord-media` is killed; the PipeWire stream is closed). The `network` permission is decided at launch.
+- **Keyring:** an isolated app's keyring requests carry an owner that `lord-server` sets from the verified app id.
+
+**Limits.** There is no "allow once". Some declared permissions (Bluetooth, launching apps, notifications) have no broker call yet, so isolated apps can't use those capabilities at all; listening on a port is governed by the network permission. A Linux app running as the user could edit the permissions file.
+
+### 6.6 The per-app firewall and the Monitor
+
+[[diagram:firewall]]
+
+`lord-netperm` enforces per-app network rules in the kernel. Linux apps opened from the app launcher run in `app-lordos-<id>.scope`, `.lpk` apps in `app-lordos-lpk-<id>.scope`, and the rest of the session counts as `lordos`. All scopes are root-owned. The service loads seven cgroup eBPF programs (`connect4/6`, `sendmsg4/6`, `bind4/6`, `sock_create`) into the cgroup of `lordos.service`, finds each process's app by its cgroup ancestor, and returns allow or deny (`EPERM`). The programs are compiled into the binary and loaded with LordOS's own loader over the `bpf()` system call; libbpf and bcc are not used.
+
+- **Rules** support exact domains, wildcards, IPv4/IPv6 networks, `lan`, `internet`, ports, protocols and direction. Restrictions (no internet, no LAN, no network, no incoming) come first; then the most specific rule wins, with deny beating allow at equal specificity; then trusted apps; then the mode (silent, the default, or off). `npcompile.c` precomputes this into hash and longest-prefix-match maps. A test runs the kernel's decision code against the reference decision maker over 480,000 random connections: 0 differences.
+- **Domain names** come only from the system resolver: systemd-resolved's monitor interface or, without it, replies from port 53 of the configured servers read by a receive-only packet socket. Answers an app received on its own sockets are never trusted.
+- **Escapes.** The cgroup tree is root-owned, so an app can't move itself. A process that asks the user's systemd manager for a new unit (`systemd-run --user`) lands under `user@<uid>.service`; `lord-netperm` attaches the same programs there and holds such processes to the strictest union of that user's running restricted apps. Tested: all escape attempts denied, other users unaffected.
+- **Cost**: about 0.5 µs per UDP connect, TCP within noise, no change in throughput, since nothing runs per packet.
+- **The Monitor** shows each app's connections (from `sock_diag`), bytes, destinations by country from a local database, and a per-app Rule switch. No address ever leaves the machine for lookups: no reverse DNS, no online geolocation.
+
+**Limits.** "Ask" mode is designed but behaves as silent today. There is no interface yet for domain rules or per-destination switches (the engine and the API support them). ICMP is blocked only by "no network"; connections to an already-open port aren't checked. Settings also offers non-network restrictions (camera, microphone, screen, USB, Bluetooth, files, notifications): they are stored, but **no component enforces them yet**.
+
+### 6.7 Helpers that process untrusted data
+
+[[diagram:helpers]]
+
+`lord-doc` (PDF, archives, fonts, scanner images), `lord-media` (video, audio, photos, camera), `lord-maild` (mail, calendars, contacts) and `lord-vault` (secrets) share one hardened sandbox, `sandbox_apply_helper()`:
+
+- no `socket`, `socketpair`, `connect`, `bind`, `listen`, `accept`; no `execve`; `clone` only for threads; seccomp on every thread, and if seccomp can't be applied the helper exits;
+- files only through descriptors passed by `lord-server`; ioctls only by class (DRM, V4L2, DMA-BUF) where needed;
+- results returned in sealed shared memory, validated by `lord-server`.
+
+`lord-media` doesn't even receive the PipeWire socket; audio flows through a shared ring whose stream belongs to `lord-server`. `lord-maild` can't create sockets: it asks `lord-server`, which connects only to servers in the accounts file (and, after the user asks to load images, only to public addresses on ports 80/443 for ten minutes) and hands over the connected socket. `build/sandbox-test helper` passes 17 of 17 checks.
+
+### 6.8 Package signing and trust levels
+
+`.lpk` packages carry a manifest of every file's SHA-256 and an Ed25519 signature over it. SHA-256 and Ed25519 are LordOS's own code (Ed25519 following TweetNaCl's arithmetic), tested against NIST and RFC 8032 vectors (55 of 55). Verification happens in C at install and at load. The Store shows the trust level: **LordOS** (official key, compiled into the binary so no file can add one), **Verified author** (listed in the signed catalog), **Signed by <name>**, or **Unsigned** with a warning. Updates must be signed with the same key. A signed catalog carries a revocation list. If you edit an installed app, LordOS marks it "Modified by you", can restore the original, or can share your version signed with your own key, with credit to the original.
+
+**Status:** official packages are signed today with a development key; the final key replaces it for the public release. A signed LordOS app repository for the Store is not built yet.
+
+### 6.9 Release signing
+
+Every release file (the `.deb`, the ISO and the Raspberry Pi image) is listed with its SHA-256 in `SHA256SUMS`, and `SHA256SUMS` is signed with the LordOS release key (Ed25519). The public key is `tools/release/lordos-release.pub.pem`, also embedded in the Debian installer. Its fingerprint (SHA-256 of the DER public key) is:
+
+`c7155b8e6bbbb180f907381994d06af76d333016cd6f3facf67cadd053ea108e`
+
+The private key lives only on the maintainer's machine, never in the repository or on a build machine. §11 shows how to check a download.
+
+### 6.10 The vault
+
+`lord-vault` keeps passwords and the session keyring in `.lvault` files: one random 32-byte vault key, wrapped once per unlock method (Argon2id password with a cost calibrated per machine, FIDO2 `hmac-secret` with LordOS's own CTAP2 client, key file, password plus key file, recovery key); content sealed with XChaCha20-Poly1305 with the whole header as associated data; attachments sealed separately; atomic saves with a backup. Every flipped byte and every truncation is detected (1,165 of 1,165 in the test). Secrets live in an `mlock`ed arena excluded from core dumps and wiped on free, in a process that is not dumpable. The Passwords window runs in its own sandboxed process, so revealed values never enter the desktop's JavaScript. The keyring opens at login with the password `lord-sessiond` verified, and serves Linux apps through LordOS's own Secret Service implementation. Real hardware security keys are not yet tested.
+
+### 6.11 Protected windows
+
+A window marked protected (Passwords is) is painted black in every path that copies pixels out: screenshots, recordings, thumbnails, the remote desktop, and Wayland menus and fullscreen. The real monitor shows it normally. Linux apps have no screen-capture protocol to begin with.
+
+### Source files
+
+- [server/src/sec/sandbox.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/sandbox.c), [server/src/sec/brokersrv.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/brokersrv.c), [server/src/sec/perms.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/perms.c), [server/src/sec/cgroup.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/cgroup.c)
+- [server/src/netperm/np.bpf.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/np.bpf.c), [server/src/netperm/netperm.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/netperm.c), [server/src/fw/rules.c](https://github.com/lordbasex/LordOS/blob/main/server/src/fw/rules.c)
+- [server/src/sec/sign.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/sign.c), [server/src/pkg/crypto.c](https://github.com/lordbasex/LordOS/blob/main/server/src/pkg/crypto.c), [tools/release/sign-release.sh](https://github.com/lordbasex/LordOS/blob/main/tools/release/sign-release.sh)
+- [server/src/vault/vault.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/vault.c), [server/src/vault/vfile.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/vfile.c)
+- [server/src/media/capture.c](https://github.com/lordbasex/LordOS/blob/main/server/src/media/capture.c)
+
+## 7. Performance
+
+All figures below were measured by the project and are documented in the files cited. Most come from virtual machines; real-hardware measurements are noted as such.
+
+### 7.1 Memory and idle
+
+| Measurement | Value | Where |
+|---|---|---|
+| Whole system, live ISO, idle after a minute (4 GB, 4 cores) | 465 MB used, CPU 99 % idle | VM 117, `docs/ISO.md` |
+| Whole system, installed from the ISO, idle | 487 MB used, CPU 99 % idle | VM 120, `docs/ISO.md` |
+| Boot, live ISO with UEFI | 16.3 s (4.9 s kernel + 11.4 s userspace) | VM 117, `docs/ISO.md` |
+| `lord-server` without a 3D card (Mesa not loaded) | about 32 MB RSS | `docs/GPU.md` |
+| A user session (`lord-server`), remote desktop tests | about 50 MB; login screen 41 MB | VM 118, `docs/REMOTE.md` |
+| One isolated `.lpk` app | 13.7 MB RSS | VM 122, `docs/PRIVACY.md` |
+
+### 7.2 Drawing
+
+- Dragging a window on one 1280×800 display on the CPU path: about 6.7–6.9 ms of work per frame, around 120 frames per second (VM 118, `docs/DISPLAYS.md`).
+- The same window on a 2560×1600 display at 150 %: about 5.1 ms per frame.
+- Video: painting straight from the decoded frame when only an opaque video changed brought `lord-server` from 42 % to 13 % of a core for a windowed 1080p video, and from 92 % to 15 % fullscreen (`docs/ROADMAP.md`, media).
+- The Monitor closed costs nothing: its sampling thread doesn't exist until opened (`docs/MONITOR.md`).
+
+### 7.3 GPU
+
+On the VMs only a software renderer was available. With it, the CPU path is cheaper than "GPU" composition, which is why LordOS uses the CPU path when the only renderer is a software one. The GPU path's real benefit (composition and present close to free, zero-copy fullscreen) is expected on real cards, but **real AMD and Nvidia hardware has not been measured yet**.
+
+### 7.4 The Raspberry Pi 5
+
+The Raspberry Pi 5 is the only supported board. Results on a real board (16 GB, SD card, without a monitor), from `docs/RASPBERRY.md`:
+
+| Measurement | Value |
+|---|---|
+| Building every LordOS binary on the board | 1 min 02 s, 0 warnings |
+| `make -C server test` | 23 passed, 0 failed, 0 skipped |
+| NEON blit and mask vs. plain C | 9.90 → 4.33 ms and 11.09 → 5.49 ms per screen (2.0–2.3×), bit-identical |
+| Idle at the login screen, headless | `lord-server` 36 MB RSS, 0.6 % CPU; system 450 MB of 16 GB; 38–43 °C, no throttling |
+| Building the SD image on the board | 8 min 18 s; 503 MB compressed |
+| Building the LordOS kernel on the board | about 50 min per flavour |
+
+**The LordOS kernel.** The Raspberry Pi's own kernel doesn't build Landlock. Without it, the document-helper hostile test fails 5 of its 25 filesystem checks and the sandbox test can't run. LordOS builds the Raspberry Pi kernel from its own source and default configuration, changing only three options (Landlock on, the LSM list, the version suffix), and pins it so a newer archive kernel can't replace it. The image also enables the memory cgroup, which Raspberry Pi turns off at boot.
+
+**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`).
+
+**Not verified yet on the board:** anything with a monitor attached (modesetting, GPU composition on screen, frame rates), the desktop session, and booting the built image.
+
+### 7.5 Modern PCs
+
+There are no measurements on real PCs in the repository yet. The ISO is tested on virtual machines (UEFI and BIOS); testing on a real AMD machine from the live USB is planned.
+
+### Source files
+
+- [docs/ISO.md](https://github.com/lordbasex/LordOS/blob/main/docs/ISO.md), [docs/RASPBERRY.md](https://github.com/lordbasex/LordOS/blob/main/docs/RASPBERRY.md), [docs/FANS.md](https://github.com/lordbasex/LordOS/blob/main/docs/FANS.md), [docs/DISPLAYS.md](https://github.com/lordbasex/LordOS/blob/main/docs/DISPLAYS.md)
+- [tools/rpi/build-kernel.sh](https://github.com/lordbasex/LordOS/blob/main/tools/rpi/build-kernel.sh), [tools/rpi/build-img.sh](https://github.com/lordbasex/LordOS/blob/main/tools/rpi/build-img.sh)
+- [server/src/canvas.c](https://github.com/lordbasex/LordOS/blob/main/server/src/canvas.c)
+
+## 8. Visual experience
+
+- **A design guide.** Apps follow a shared guide (`docs/DESIGN.md`): an 8 px spacing grid, a small type scale, consistent control heights and one accent-coloured action per view. The tokens are exported by the SDK (`spacing`, `typeScale`, `controlSize`), and every app went through documented before-and-after polish passes in light, dark, right-to-left and small windows.
+- **Themes.** A theme is a complete desktop written in React: menu bar, Dock, app launcher, Control Center and window frame, plus its tokens. LordOS ships a default theme with a menu bar and a Dock, and a Classic theme with a taskbar and a start menu. Themes switch live; settings persist.
+- **Light and dark, accents.** Both modes and the accent colour apply live to native apps, isolated apps and, through the portal and GSettings, GTK apps.
+- **Right to left.** The whole interface mirrors for Arabic, Hebrew and similar scripts, including isolated apps, which follow the session's language live.
+- **Lumo.** LordOS's mascot is Lumo, a small celestial fox, used in welcome screens, empty states and brand material, with a fixed set of poses defined in the brand guide.
+- **Accessibility today:** a "reduce motion" setting that turns off decorative animations, keyboard shortcuts throughout, and scalable displays up to 200 %. A screen reader, zoom and high contrast are on the roadmap and **not built yet**.
+
+### Source files
+
+- [docs/DESIGN.md](https://github.com/lordbasex/LordOS/blob/main/docs/DESIGN.md), [docs/LORDOS-BRAND.md](https://github.com/lordbasex/LordOS/blob/main/docs/LORDOS-BRAND.md)
+- [themes](https://github.com/lordbasex/LordOS/tree/main/themes), [sdk/controls.jsx](https://github.com/lordbasex/LordOS/blob/main/sdk/controls.jsx), [sdk/i18n.js](https://github.com/lordbasex/LordOS/blob/main/sdk/i18n.js)
+
+## 9. Extensibility
+
+- **The SDK** (`@lordos/sdk`) is the only thing apps import: windows, settings, theme tokens, controls, files, media, notifications, keyring, printing and more. Apps don't import from themes, so any app works in any theme.
+- **Writing an app** means a folder with `manifest.json` and `index.jsx`. `node tools/lpk.mjs <folder>` bundles it without React or the SDK, adds the icon and translations, and signs it if a key is given; `keygen`, `sign`, `verify` and `catalog` cover the rest. Apps can include WebAssembly modules and draw raw pixels with `<Image pixels>`.
+- **Themes** follow a fixed contract (`Desktop`, `MenuBar`, `Dock`, `Launcher`, `ControlCenter`, `WindowFrame`, tokens), documented in `themes/README.md`, with the Classic theme as a template.
+- **Linux interoperability** is through standards: Wayland, the Settings portal, the Secret Service, the notifications service, `mimeapps.list` default apps and `.desktop` files.
+- **Automation:** there is no scripting or automation API beyond the SDK today. Integrations with AI assistants (for example through the Model Context Protocol) **do not exist in LordOS**; they are only a possible future direction and would have to respect the same rule that JavaScript can't execute commands.
+
+### Source files
+
+- [sdk](https://github.com/lordbasex/LordOS/tree/main/sdk), [apps/README.md](https://github.com/lordbasex/LordOS/blob/main/apps/README.md), [themes/README.md](https://github.com/lordbasex/LordOS/blob/main/themes/README.md)
+- [docs/NATIVE-APPS.md](https://github.com/lordbasex/LordOS/blob/main/docs/NATIVE-APPS.md), [docs/WASM.md](https://github.com/lordbasex/LordOS/blob/main/docs/WASM.md), [examples/apps/fractal](https://github.com/lordbasex/LordOS/tree/main/examples/apps/fractal)
+
+## 10. Roadmap and limitations
+
+### 10.1 Where things stand
+
+Milestones M1 to M9 are complete in 0.7.0 Beta: the display server, the UI engine, the SDK and themes, the terminal, languages and complex scripts, Linux app compatibility, packages and system services, sessions, isolation and the firewall, and the M9 app suites (documents and printing, media, system apps, passwords, hardware settings, mail and calendar). The final ISO was built and tested on virtual machines on 18 October 2026.
+
+### 10.2 Known limitations
+
+- Real hardware: AMD and Nvidia GPUs, real monitors, laptops (battery, backlight, lid), Bluetooth controllers, printers and scanners, FIDO2 keys and real mail providers are untested.
+- The Raspberry Pi 5 hasn't been tested with a monitor, and its built image hasn't been booted yet.
+- Linux apps are not sandboxed; no Xwayland.
+- Firewall: no ask mode, no domain-rule interface, non-network restrictions not enforced.
+- Permissions: no "allow once"; camera and microphone use by Linux apps isn't shown.
+- Secure Boot must be turned off; signing with a shim is pending.
+- Package downloads use HTTP (signed and hashed).
+- Remote desktop has no audio.
+- Accessibility (screen reader, zoom, high contrast) is not built.
+
+### 10.3 Next
+
+Before the final release: the final ISO with everything and a Raspberry Pi 5 image tested on the real board. After it, as planned in `docs/ROADMAP.md`: a desktop virtualization app built on KVM and QEMU; an Android container with LineageOS and apps from LordOS's Store; the firewall's ask mode; accessibility; and a full demo video.
+
+### Source files
+
+- [docs/ROADMAP.md](https://github.com/lordbasex/LordOS/blob/main/docs/ROADMAP.md), [CHANGELOG.md](https://github.com/lordbasex/LordOS/blob/main/CHANGELOG.md)
+
+## 11. How to verify the project yourself
+
+### 11.1 Build it
+
+On a development machine with Node.js, bundle the themes, SDK and apps:
+
+```
+npm install && npm run build
+```
+
+On Debian 13, build the binaries and run the tests:
+
+```
+sudo apt-get install -y --no-install-recommends build-essential
+make -C server -j4
+make -C server test # every self-contained suite
+make -C server test-full # adds the helpers, the sandbox and the HarfBuzz comparison
+```
+
+`make test` fails if any suite fails; a suite whose tool or data isn't installed reports "skipped" rather than passing silently. The sandbox tests need a kernel with Landlock. The ISO and the Raspberry Pi image are built as described in `docs/ISO.md` and `docs/RASPBERRY.md`.
+
+### 11.2 What the tests cover
+
+- **Terminal and text:** the VT emulator, OpenType shaping against HarfBuzz, Unicode bidi against the official test file, input methods, Thai word breaking against libthai.
+- **Security:** the sandbox (app, network, helper), signing (NIST and RFC 8032 vectors), package state, archive path rules against malicious archives, `lord.fs` protections, the firewall rules (with 20,000 JSON mutations and 30,000 random operations against a linear reference), the DNS reader (200,000 random packets), the kernel-map compiler (480,000 connections), and the kernel integration test (18 of 18 on a VM).
+- **Parsers:** mail, MIME, HTML sanitizer, iCalendar, vCard and XML (30,953 checks with mutation fuzzing), the vault format, importers, QR, CBOR, D-Bus marshalling, the country database reader, journal, TZif and IPP.
+- **Engine and hardware:** layout and painting, NEON vs. C, the touchpad driver with recorded gestures, fans on fake sysfs trees, display arrangement, sound, and the WebAssembly specification suite.
+
+On the final ISO build: `make -C server test` reported 23 passed, 0 failed, 1 skipped (bidi data not installed).
+
+### 11.3 Check a release
+
+Download `SHA256SUMS`, `SHA256SUMS.sig`, the release files and the public key (`tools/release/lordos-release.pub.pem`). Check that the key's fingerprint is `c7155b8e6bbbb180f907381994d06af76d333016cd6f3facf67cadd053ea108e`, then, with OpenSSL 3:
+
+```
+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
+```
+
+### 11.4 Check a running system
+
+- `systemctl status lord-netperm lord-fand lordos` shows the services; the ISO test confirmed seven BPF programs attached.
+- `cat /proc/<pid>/status | grep -E 'Seccomp|NoNewPrivs'` on a `lord-server --app` process shows the sandbox.
+- `systemd-cgls` shows the root-owned `lordos-session-<uid>` tree with one scope per app.
+- Remote desktop: `ss -ltn` shows nothing on port 5673 until you enable it in Settings → Sharing.
+
+## 12. License and credits
+
+LordOS's code is released under the **MIT license**. Third-party components keep their own licenses, listed in `THIRD_PARTY.md`: QuickJS and stb (vendored), Monocypher (CC0/BSD-2), the EFF word list (CC BY 3.0 US), the common-password list (MIT), DB-IP Lite country data (CC BY 4.0), Natural Earth (public domain), and the Inter, JetBrains Mono and Plus Jakarta Sans fonts (OFL).
+
+LordOS is created by the **IPERFEX** group: **Pablo Miranda** and **Federico Pereira**.
+
+## 13. Glossary
+
+- **Broker:** the single socket through which an isolated app asks `lord-server` for anything that touches the user's things; every request is checked in C.
+- **cgroup (v2):** a kernel mechanism that groups processes to account for and limit resources. LordOS gives each app its own group, a "scope", and uses it to identify the app in the firewall.
+- **Compositor:** the program that combines the windows of all apps into the final image on screen.
+- **DRM/KMS:** the kernel interfaces for graphics devices and for setting display modes.
+- **eBPF:** small verified programs that run inside the kernel; LordOS attaches them to cgroups to decide network connections.
+- **evdev:** the kernel interface for input devices.
+- **Helper:** a small LordOS process that handles untrusted data or secrets in a stricter sandbox (`lord-doc`, `lord-media`, `lord-maild`, `lord-vault`).
+- **Landlock:** a kernel feature that lets an unprivileged process restrict which files and network ports it, and its children, may use.
+- **`.lpk`:** LordOS's package format for installable native apps.
+- **`.lvault`:** LordOS's encrypted vault file format.
+- **Powerbox:** a file dialog drawn by the system that hands the app only the file the user chose.
+- **QuickJS:** a small JavaScript engine written in C.
+- **Scope:** a cgroup for one app, such as `app-lordos-lpk-<id>.scope`.
+- **seccomp-bpf:** a kernel filter that restricts which system calls a process may make.
+- **Secret Service:** the freedesktop D-Bus standard Linux apps use to store secrets.
+- **Wayland:** the protocol between graphical apps and the compositor.
+
+## 14. Where to read more
+
+| Chapter | Documents in `docs/` |
+|---|---|
+| 1. Vision | ARCHITECTURE.md, LORDOS-BRAND.md |
+| 2. Architecture | ARCHITECTURE.md, NETWORK.md, FANS.md, SETTINGS.md, SYSTEM.md |
+| 3. Compositor | GPU.md, DISPLAYS.md, WINDOWS.md, TRACKPAD.md, WAYLAND.md, SESSIONS.md, REMOTE.md |
+| 4. UI engine | ARCHITECTURE.md, LANGUAGES.md, TERMINAL.md |
+| 5. Applications | NATIVE-APPS.md, PACKAGES.md, WASM.md, FILES.md, MEDIA.md, DOCUMENTS.md, MAIL.md, ISO.md, INSTALL-DEBIAN.md |
+| 6. Security | PRIVACY.md, FIREWALL.md, MONITOR.md, SIGNING.md, PASSWORDS.md, MEDIA.md, REMOTE.md |
+| 7. Performance | ISO.md, RASPBERRY.md, FANS.md, DISPLAYS.md, GPU.md |
+| 8. Visual experience | DESIGN.md, LORDOS-BRAND.md, LANGUAGES.md, DOCK.md |
+| 9. Extensibility | NATIVE-APPS.md, WASM.md, and `apps/README.md`, `themes/README.md` |
+| 10. Roadmap | ROADMAP.md and `CHANGELOG.md` |
diff --git a/web/content/paper/paper.es.md b/web/content/paper/paper.es.md
new file mode 100644
index 0000000..d672412
--- /dev/null
+++ b/web/content/paper/paper.es.md
@@ -0,0 +1,534 @@
+## Resumen
+
+LordOS es una distribución GNU/Linux libre basada en Debian 13 que trae un entorno de escritorio propio, construido desde sus componentes fundamentales sobre Debian y Wayland. En lugar de GNOME o KDE, tiene su propio servidor gráfico y compositor Wayland escritos en C (`lord-server`), su propio motor de interfaz (React corriendo sobre el motor de JavaScript QuickJS, con layout, pintado y texto en código C nativo), sus propias apps nativas y sus propios servicios de seguridad: un lanzador de apps en caja de arena, un broker de permisos, un registro de permisos por app, un firewall por app que aplica el kernel, firma de paquetes y una bóveda de contraseñas cifrada. Reutiliza lo que está maduro y muy revisado: el kernel Linux, Debian y sus paquetes, Mesa, PipeWire, el protocolo Wayland y unas pocas bibliotecas (FFmpeg, Poppler, libarchive, OpenSSL, Monocypher) que quedan encerradas en pequeños procesos ayudantes aislados.
+
+Este documento describe el diseño y el estado actual de la versión **0.7.0 Beta** (octubre de 2026) para un lector técnico que quiere verificar el proyecto en lugar de creer en él a ciegas. Cada afirmación remite a un archivo del repositorio público. Los números son los medidos en los registros de prueba del proyecto, e indican dónde se midieron. Lo que está diseñado pero no construido aparece marcado como tal.
+
+## 1. Visión
+
+### 1.1 El problema
+
+Un escritorio Linux moderno se arma con muchos proyectos independientes: un servidor gráfico o compositor, un toolkit, un gestor de sesiones, un demonio de configuración, un llavero, un gestor de red, una interfaz de firewall y las apps. Cada uno es bueno en lo suyo, pero las costuras entre ellos son donde las cosas se vuelven lentas, inconsistentes o inseguras. Tres costuras en particular motivaron LordOS:
+
+- **Peso.** Un escritorio que dibuja su interfaz con un motor web, o que carga varios toolkits a la vez, necesita cientos de megabytes antes de que el usuario abra nada. LordOS quiere andar cómodo en máquinas modestas y en una Raspberry Pi 5.
+- **Confianza en las apps.** En un escritorio Linux tradicional, cada programa que corrés puede leer toda tu carpeta personal, grabar el micrófono, abrir cualquier conexión de red y leer el portapapeles. El aislamiento existe, pero suele ser un agregado que el escritorio mismo no entiende.
+- **Visibilidad.** Rara vez ves qué app está hablando con qué servidor, y menos todavía podés decir "esta app no puede usar internet" de una forma que la app no pueda esquivar.
+
+### 1.2 Principios
+
+El proyecto sigue una lista corta de reglas, escritas en `AGENTS.md` y `docs/ARCHITECTURE.md`:
+
+1. **Ser dueños de lo que el usuario toca; reutilizar los cimientos.** El servidor gráfico, el compositor, el motor de interfaz, las apps y los servicios de seguridad son código de LordOS. El kernel, los paquetes de Debian, Mesa, PipeWire y el protocolo Wayland se reutilizan.
+2. **Una política de dependencias estricta.** Dentro de LordOS no se usan X11, wlroots, libdrm, libinput, WebKit, GTK ni Qt. Las bibliotecas que leen datos no confiables las enlazan solo ayudantes aislados, nunca el compositor.
+3. **La interfaz no puede ejecutar comandos.** El JavaScript de LordOS no tiene ninguna API para ejecutar programas arbitrarios. Hay tres excepciones angostas y sin argumentos (la shell de inicio de la Terminal, lanzar una app `.desktop` instalada y arrancar una app `.lpk` instalada en su caja de arena).
+4. **Root solo a través de puertas cerradas.** Todo lo que necesita root pasa por una tabla fija de acciones validadas o por un servicio pequeño y dedicado con un protocolo cerrado.
+5. **El camino por CPU siempre tiene que funcionar.** La composición en GPU es una optimización, nunca un requisito.
+6. **El compositor nunca espera.** Ayudantes, apps y servicios hablan con `lord-server` por sockets no bloqueantes; una app colgada se cuelga solo a sí misma.
+7. **Verificar en un sistema real.** Cada hito se comprueba en una máquina virtual con capturas reales antes de marcarlo como terminado, y no se declara compatibilidad que no se probó.
+
+### Archivos fuente
+
+- [AGENTS.md](https://github.com/lordbasex/LordOS/blob/main/AGENTS.md)
+- [docs/ARCHITECTURE.md](https://github.com/lordbasex/LordOS/blob/main/docs/ARCHITECTURE.md)
+
+## 2. Arquitectura
+
+### 2.1 Capas
+
+[[diagram:layers]]
+
+De abajo hacia arriba:
+
+- **El kernel Linux** provee DRM/KMS para las pantallas, evdev para la entrada y las funciones de seguridad sobre las que se apoya LordOS: Landlock, seccomp-bpf, cgroups v2 y eBPF. En PC es el kernel de Debian; en la Raspberry Pi 5 es la compilación de LordOS del kernel de Raspberry Pi con Landlock activado (§7.4).
+- **Debian 13** provee el espacio de usuario: `dpkg` y el archivo de paquetes, systemd, Mesa, PipeWire, `libwayland`, `libxkbcommon`, CUPS, BlueZ y el resto.
+- **`lord-server`** es el servidor gráfico y compositor Wayland. Maneja las pantallas y la entrada directamente, compone y sirve el protocolo Wayland a las apps de Linux.
+- **El motor de interfaz** vive dentro de `lord-server`: QuickJS corre la interfaz en React, y código C nativo hace el layout, el pintado y el texto.
+- **Las apps** son de tres tipos: las apps incluidas y el tema, que corren en el contexto de JavaScript de `lord-server`; las apps `.lpk` instaladas, cada una en su propio proceso aislado con su propia instancia del motor; y las apps de Linux, que se conectan al compositor como clientes Wayland comunes.
+
+### 2.2 Procesos y privilegios
+
+[[diagram:processes]]
+
+Un LordOS en marcha tiene pocos procesos, con roles bien separados:
+
+| Proceso | Corre como | Rol |
+|---|---|---|
+| `lord-sessiond` | root | pantalla de inicio de sesión, sesiones, prestar la pantalla y la entrada a la sesión visible, escritorio remoto |
+| `lord-netd` | root | la red del sistema: DHCP, Wi-Fi, VPN; solo las acciones `net-*` |
+| `lord-netperm` | root (capacidades limitadas) | reglas de red por app, aplicadas con eBPF de cgroup |
+| `lord-fand` | root (sin capacidades) | control de ventiladores según la temperatura |
+| `lord-server` | el usuario | uno por sesión: compositor, motor de interfaz, broker |
+| `lord-server --app <id>` | el usuario, aislado | uno por app `.lpk` en ejecución (y Contraseñas) |
+| `lord-doc`, `lord-media`, `lord-maild`, `lord-vault` | el usuario, aislados | ayudantes que procesan datos no confiables o secretos |
+| pantalla de inicio de sesión | `lordos-greeter` | dibuja la interfaz de inicio; nunca verifica contraseñas por su cuenta |
+
+Cada proceso root tiene una interfaz angosta y documentada. La §6.3 las describe.
+
+### 2.3 Qué es propio y qué se reutiliza
+
+| Propio (en este repositorio) | Reutilizado |
+|---|---|
+| Servidor gráfico y compositor Wayland (C) | Kernel Linux |
+| Motor de interfaz: nodos nativos, layout flexbox, rasterizador, shaping de texto, bidi, métodos de entrada | Debian 13 y sus paquetes; `dpkg` |
+| Renderizador de React (configuración de host para `react-reconciler`) | React 19.3.1, `react-reconciler` 0.34 (empaquetados en el tema) |
+| Apps nativas y temas | QuickJS 2025-04-26 (incluido como código fuente) |
+| Caja de arena, broker, permisos, firma, servicio de firewall, bóveda | Mesa (opcional), PipeWire, `libwayland`, `libxkbcommon` |
+| Gestor de sesiones, servicio de red, servicio de ventiladores | systemd, systemd-resolved, BlueZ, CUPS, wpa_supplicant, OpenVPN, el demonio de strongSwan |
+| Motor de paquetes Debian (OpenPGP, xz, HTTP, resolución de dependencias) | FFmpeg, Poppler, libarchive, OpenSSL, Monocypher (solo en ayudantes) |
+| Driver de touchpad, emulador de terminal, intérprete de WebAssembly | stb (fuentes e imágenes), fuentes bajo la OFL |
+
+LordOS habla con varios servicios de Debian por sus propios protocolos, con clientes propios: D-Bus (BlueZ, perfiles de energía, fecha y hora), IPP (CUPS), el protocolo de PulseAudio (PipeWire) y el Secret Service. No se usan libdbus, sd-bus, libcups, libpulse, libbpf ni libapt.
+
+### 2.4 Servicios del sistema
+
+- **Red (`lord-netd`).** La red pertenece al sistema, no a una sesión. `lord-sessiond` arranca `lord-netd` al iniciar, con una ruta fija y sin argumentos, así la máquina tiene dirección antes de que alguien inicie sesión. Solo ejecuta las acciones cerradas `net-*`: su propio cliente DHCP y código netlink, Wi-Fi a través del `wpa_supplicant` de Debian, WireGuard con el código netlink propio de LordOS, OpenVPN, IPsec/IKEv2 a través del `charon` de strongSwan manejado por VICI con un cliente propio de LordOS y, opcionalmente, túneles OpenConnect, PPTP y compatibles con Fortinet. Habla solo con los ayudantes root de las sesiones, por un socket que acepta únicamente uid 0.
+- **Ventiladores (`lord-fand`).** Un servicio root que lee la temperatura de la CPU cada 2 s y escribe el ciclo de trabajo de los ventiladores según un perfil, desde temprano en el arranque. Maneja solo los ventiladores que encontró su propio escaneo: el conector de ventilador de la Raspberry Pi 5 y controladores de placa madre de una lista permitida. Nunca escribe ventiladores de notebooks, GPU ni desconocidos. Al detenerse, o después de un fallo, restaura la configuración original del kernel. No ejecuta programas, no tiene red, ni capacidades, ni nodos de dispositivo.
+- **Configuración de hardware.** Pantallas (modos desde KMS con nombres EDID, una reversión de 15 segundos con "¿mantener esta configuración?", persistencia por pantalla, rotación, Luz nocturna), Bluetooth a través de BlueZ, batería y perfiles de energía, inactividad y tapa, fecha y hora, notificaciones para apps de Linux y apps predeterminadas. Los cambios llegan como uevents del kernel y señales de D-Bus; nada consulta en bucle.
+
+### Archivos fuente
+
+- [server/src/main.c](https://github.com/lordbasex/LordOS/blob/main/server/src/main.c)
+- [server/src/admin.c](https://github.com/lordbasex/LordOS/blob/main/server/src/admin.c)
+- [server/src/net/netd.c](https://github.com/lordbasex/LordOS/blob/main/server/src/net/netd.c)
+- [server/src/fan/fand.c](https://github.com/lordbasex/LordOS/blob/main/server/src/fan/fand.c)
+- [server/src/hw](https://github.com/lordbasex/LordOS/tree/main/server/src/hw)
+
+## 3. El compositor
+
+### 3.1 Pantallas sin libdrm
+
+`lord-server` configura los modos de pantalla con los ioctls de DRM del kernel directamente (`kms.c`): enumera conectores, CRTC y planos, reserva buffers y cambia de página en el refresco vertical. Elige la placa que tiene conectores, no simplemente `card0`, algo importante en placas donde el controlador de pantalla y la GPU son dispositivos separados (en la Raspberry Pi 5, `vc4` y `v3d`).
+
+### 3.2 Dos formas de armar un cuadro
+
+- **Camino por CPU.** La interfaz y las ventanas de las apps se copian a un lienzo, y se presenta un buffer "dumb" con un cambio de página. No necesita nada más que el kernel. Es el predeterminado cuando no hay una placa con 3D, y `LORD_GPU=0` lo fuerza (el modo seguro del menú de arranque lo usa).
+- **Camino por GPU.** GBM, EGL y GLES2 de Mesa (`server/src/gpu/gpu.c`). La interfaz pasa a ser una textura, y en cada cuadro se sube solo la región que cambió. Las ventanas de las apps no se copian al lienzo de la interfaz: la interfaz deja un hueco transparente donde va cada ventana, y las texturas de las ventanas se dibujan debajo, así una app que solo cambia su contenido no provoca un repintado de la interfaz. Las apps pueden entregar buffers de GPU (`linux-dmabuf`) sin copias, y una app a pantalla completa con un buffer adecuado se muestra directamente (scanout directo). El cursor usa el plano de cursor por hardware.
+
+El camino se elige al arrancar: una placa sin 3D (simpledrm, bochs, virtio-gpu sin virgl y otras) usa la CPU sin siquiera cargar Mesa; un renderizador OpenGL por software también vuelve a la CPU, porque componer con él cuesta más que el camino por CPU propio de LordOS. Si un cuadro por GPU falla, la GPU se apaga y el camino por CPU toma el control.
+
+**Estado:** el camino por GPU se probó con el renderizador por software de Mesa en máquinas virtuales. Falta probarlo en placas AMD y Nvidia reales.
+
+### 3.3 Ventanas y entrada
+
+- **Gestión de ventanas en C.** Mover y redimensionar corre en C, con un evento por cuadro y sin JavaScript, y la ventana que se mueve se dibuja desde su propia capa. Los cuatro bordes y las esquinas redimensionan, con cursores propios de LordOS.
+- **Entrada sin libinput.** Teclados, mouses y tabletas se leen desde evdev. Las distribuciones de teclado vienen de `libxkbcommon` (todas las distribuciones XKB, variantes y compose).
+- **Touchpad y pantalla táctil.** LordOS tiene su propio driver multitáctil (`server/src/tp`): aceleración del puntero, tocar para hacer clic y clic con dos dedos, rechazo de la palma, desplazamiento cinético y natural, pellizco y deslizamientos con tres dedos. Los gestos llegan tanto a la interfaz de LordOS como a las apps de Linux (`zwp_pointer_gestures_v1`). Se prueba con gestos grabados en `make test`.
+
+### 3.4 Compatibilidad con Wayland
+
+El compositor (`server/src/wl/wl.c`) usa solo `libwayland-server` y código generado a partir del XML de los protocolos. Ofrece: `wl_compositor`, `wl_subcompositor`, `wl_shm`, `wl_output` (uno por pantalla), `xdg_wm_base` con popups, `wl_seat` (puntero, teclado, táctil), `wl_data_device_manager` (un portapapeles compartido con LordOS), `zxdg_decoration_manager_v1`, el protocolo de decoración del servidor de KDE (para que las apps GTK 3 como Firefox tengan el marco del tema), `zxdg_output_manager_v1`, `wp_fractional_scale_v1`, `wp_viewporter`, `zwp_linux_dmabuf_v1` v4, `wp_presentation`, `zwp_relative_pointer_manager_v1`, `zwp_pointer_constraints_v1`, `zwp_pointer_gestures_v1` y `wp_cursor_shape_manager_v1`.
+
+Las ventanas de Linux entran al gestor de ventanas del SDK como cualquier otra, con título, foco, maximizar, minimizar e ícono en el Dock. Las apps que piden decoración del lado del servidor reciben el marco del tema; las que dibujan el suyo (GTK 4) lo conservan, y se recorta su sombra. Las apps GTK 4 y libadwaita siguen el modo claro u oscuro, el color de acento y el orden de los botones a través de una implementación de `org.freedesktop.portal.Settings` que `lord-server` sirve él mismo en el bus de sesión; GTK 3 los sigue a través del archivo de claves de GSettings.
+
+**Xwayland no está soportado**: LordOS no corre apps que solo hablan X11. También quedan pendientes: arrastrar y soltar, la selección primaria, los métodos de entrada de LordOS dentro de apps de Linux (`text-input`), la activación (`xdg-activation`), la sincronización explícita y los íconos de app en SVG. No se ofrece a las apps ningún protocolo de captura de pantalla.
+
+### 3.5 Varias pantallas y HiDPI
+
+Todas las pantallas conectadas se manejan a la vez, extendidas o en espejo, en un único espacio lógico, con una disposición que se recuerda por identidad EDID y manejo de conexión en caliente. Cada pantalla se pinta a su propia escala (100, 125, 150, 175 o 200 %), así el texto y los vectores se rasterizan a su resolución real. Las apps de Linux reciben un `wl_output` por pantalla y escalado fraccional. Se probó con dos salidas virtuales (1280×800 y 2560×1600) en los dos caminos; no se probaron monitores reales, paneles de notebook ni hubs DisplayPort.
+
+### 3.6 Sesiones e inicio de sesión
+
+[[diagram:sessions]]
+
+`lord-sessiond` es el gestor de sesiones propio de LordOS:
+
+- **La pantalla de inicio de sesión** es un `lord-server` que corre como el usuario sin privilegios `lordos-greeter`, con un tema especial. Envía los pedidos de inicio de sesión a `lord-sessiond`; **las contraseñas siempre las verifica el proceso root** contra `/etc/shadow`, nunca el JavaScript de la pantalla de inicio. Los intentos fallidos esperan 1, 2, 4… segundos, hasta 5 minutos.
+- **Una sesión por usuario**, y todas pueden vivir a la vez (cambio rápido de usuario). Cada una es un `lord-server` que arranca como root y suelta los privilegios enseguida.
+- **Préstamo de la pantalla.** `lord-sessiond` abre la placa gráfica y los dispositivos de entrada como root y se los presta a la sesión que está en el monitor, por un socket Unix. Al cambiar, los revoca: `EVIOCREVOKE` hace que los descriptores de entrada de la sesión anterior dejen de funcionar, y `DROP_MASTER` le quita el control de la pantalla, antes de darle algo a la sesión siguiente. La sesión visible sigue componiendo en la GPU sin ser nunca root. Una sesión fuera del monitor dibuja en memoria, y solo si alguien la está mirando de forma remota.
+- **Bloquear saca de verdad la sesión del monitor**; no es una capa dibujada encima. Si la sesión del usuario se cuelga, la pantalla de inicio sigue funcionando.
+
+**Escritorio remoto.** El mismo servicio ofrece el escritorio a un navegador de la red local en `https://<dirección>:5673` (5673 deletrea "LORD" en un teclado de teléfono). Viene **desactivado por defecto** y se activa en Ajustes → Compartir. Usa TLS 1.2 o superior con un certificado P-256 autofirmado cuya huella muestra Ajustes para comparar, una política de seguridad de contenido estricta, controles de mismo origen, esperas por IP ante inicios fallidos y una cookie de sesión `Secure`, `HttpOnly` y `SameSite=Strict`. La página de inicio nunca lista las cuentas de usuario. El proceso que atiende una conexión suelta root apenas sabe de quién es la sesión. Las actualizaciones de pantalla se envían como PNG cuando está quieta y como JPEG mientras se mueve. El audio está diseñado pero no construido. El acceso desde internet no está previsto; se recomienda una VPN.
+
+### Archivos fuente
+
+- [server/src/kms.c](https://github.com/lordbasex/LordOS/blob/main/server/src/kms.c), [server/src/gpu/gpu.c](https://github.com/lordbasex/LordOS/blob/main/server/src/gpu/gpu.c), [server/src/outputs.c](https://github.com/lordbasex/LordOS/blob/main/server/src/outputs.c)
+- [server/src/input.c](https://github.com/lordbasex/LordOS/blob/main/server/src/input.c), [server/src/tp](https://github.com/lordbasex/LordOS/tree/main/server/src/tp), [server/src/ui/grab.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/grab.c)
+- [server/src/wl/wl.c](https://github.com/lordbasex/LordOS/blob/main/server/src/wl/wl.c), [server/src/ui/portal.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/portal.c)
+- [server/src/remote/sessiond.c](https://github.com/lordbasex/LordOS/blob/main/server/src/remote/sessiond.c), [server/src/remote/monitor.c](https://github.com/lordbasex/LordOS/blob/main/server/src/remote/monitor.c), [server/src/remote/sess.c](https://github.com/lordbasex/LordOS/blob/main/server/src/remote/sess.c)
+
+## 4. El motor de interfaz
+
+### 4.1 No es un navegador
+
+La interfaz de LordOS está escrita en JavaScript con React, pero no hay ningún motor web debajo. WebKit o Chromium costarían de 100 a 300 MB de RAM por proceso y no serían código de LordOS. En cambio, el tema y las apps usan un renderizador de React (`runtime/index.js`) que crea y actualiza **nodos nativos** en C: `View`, `Text`, `Image`, más superficies para ventanas Wayland y multimedia. Los estilos son un subconjunto de CSS (flexbox, colores, bordes redondeados y por lado, sombras, desenfoque, transformaciones, transiciones) que aplica código C controlado por el proyecto. El modelo se parece a cómo un framework móvil renderiza React a vistas nativas, salvo que acá el lado "nativo" es propio de LordOS.
+
+### 4.2 Piezas
+
+- **JavaScript:** QuickJS 2025-04-26, un motor ES2023 pequeño en C, incluido como código fuente y embebido en `lord-server`.
+- **React:** React 19.3.1 con `react-reconciler` 0.34, empaquetados con esbuild dentro de cada tema. El tema predeterminado con todas las apps pesa 367 KB.
+- **Layout:** implementación propia de flexbox (`layout.c`), con ajuste de línea, bordes lógicos de inicio y fin, y espejado de derecha a izquierda.
+- **Pintado:** rasterizador 2D propio con rectángulos redondeados con antialiasing, sombras en caché, desenfoque a resolución reducida y seguimiento de daño: solo se repinta la región que cambió. En ARM, bucles NEON opcionales aceleran las copias y las máscaras, verificados bit a bit contra el código C.
+- **Texto:** los glifos se rasterizan con `stb_truetype`. El shaping es código OpenType propio de LordOS (sustituciones GSUB y posicionamiento GPOS, emoji a color), con bidi Unicode completo, unión de letras árabes, shaping índico y el Universal Shaping Engine (409 de 409 oraciones de prueba idénticas a HarfBuzz en `tests/hb_compare.py`), corte de línea CJK, separación de palabras en tailandés y fuentes de respaldo por escritura. `lord-server` no enlaza HarfBuzz, FreeType, fontconfig, fribidi ni ICU.
+- **Métodos de entrada:** coreano (hangul), japonés (kana y SKK) y chino (pinyin), en `server/src/ime.c`, sin ibus ni fcitx.
+
+[[diagram:frame]]
+
+### 4.3 Cómo llega el JavaScript al sistema
+
+El lado JavaScript llama a servicios nativos a través de las APIs `lord.*` implementadas en C (`server/src/ui/js_*.c`): `lord.fs` (archivos), `lord.settings`, `lord.net`, `lord.pkg`, `lord.media`, `lord.mail`, `lord.vault`, `lord.fw`, `lord.monitor`, `lord.fan` y otras. Cada llamada valida sus argumentos en C. Las reglas son estrictas:
+
+- `lord-server` corre sin root, y **ninguna API ejecuta comandos arbitrarios**.
+- `lord.fs` escribe solo en la carpeta personal y en los montajes propios del usuario, no tiene un "borrar" general (solo mover a la Papelera) y rechaza las carpetas que el sistema lee para lanzar o instalar algo o que guardan decisiones de seguridad: `~/.local/share/applications`, `~/.config/autostart`, la carpeta de apps instaladas, `settings.json`, el archivo de permisos, las reglas del firewall, el archivo de cuentas de correo y la carpeta de la bóveda.
+- Todo lo que necesita root pasa por `admin.c`: una tabla cerrada de acciones con argumentos validados del lado root, rutas de programa fijas y configuración generada por LordOS, nunca texto del usuario pasado a una shell. Las contraseñas pasan por la entrada estándar, nunca por la línea de comandos.
+- El trabajo largo nunca bloquea un cuadro: ayudantes y servicios se consultan desde el bucle principal sin esperar.
+
+### 4.4 Idiomas
+
+La interfaz viene en inglés (el predeterminado), español y portugués, y se suman más idiomas como paquetes de idioma sin cambiar código. El texto pasa por `t('namespace.key')` del SDK, con plurales y formatos regionales. Toda la interfaz se espeja para los idiomas de derecha a izquierda, y la región (`LANG`/`LC_*`) se pasa a las apps de Linux. `node tools/i18n-check.mjs` verifica que cada clave exista en todos los idiomas y que no aparezcan marcas de terceros en la interfaz.
+
+### Archivos fuente
+
+- [runtime/index.js](https://github.com/lordbasex/LordOS/blob/main/runtime/index.js), [sdk/index.js](https://github.com/lordbasex/LordOS/blob/main/sdk/index.js)
+- [server/src/ui/js.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/js.c), [server/src/ui/node.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/node.c), [server/src/ui/layout.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/layout.c), [server/src/ui/paint.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/paint.c)
+- [server/src/ui/shape.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/shape.c), [server/src/ui/otf.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/otf.c), [server/src/ui/bidi.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/bidi.c), [server/src/ime.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ime.c)
+- [server/src/ui/js_sys.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/js_sys.c), [server/src/fsops.c](https://github.com/lordbasex/LordOS/blob/main/server/src/fsops.c)
+
+## 5. Aplicaciones
+
+### 5.1 Apps nativas
+
+LordOS trae alrededor de treinta apps nativas, todas apps React sobre el mismo motor y SDK: Archivos, Ajustes, Terminal, Tienda, Editor de texto, Notas, Calculadora, Monitor, Visor de PDF, Fuentes, Emoji y símbolos, Escáner, Fotos, Reproductor, Capturas, Cámara, Grabadora, Contraseñas, Discos, Copias de seguridad, Registros, Reloj, Ayuda, Mail, Calendario, Contactos, Recordatorios, Acerca de y el instalador. Algunas para destacar:
+
+- **Terminal:** emulador propio compatible con xterm, en C, con pestañas, paneles divididos, perfiles, imágenes en línea y Sixel, y sesiones que sobreviven a un reinicio de `lord-server`.
+- **Monitor:** CPU, memoria, discos, procesos, refrigeración y conexiones de red por app en un mapa del mundo, con búsqueda de país desde una base de datos local. Su hilo de muestreo existe solo mientras la app está abierta.
+- **Discos:** lector SMART propio, formateo y pendrives de arranque verificados con SHA-256.
+- **Copias de seguridad:** instantáneas con enlaces duros y cifrado opcional, que corren con prioridad baja.
+
+### 5.2 Apps `.lpk` instalables
+
+Las apps nativas de terceros se empaquetan como `.lpk`: un tar comprimido con gzip con un manifiesto, el `app.js` empaquetado, un ícono obligatorio y traducciones y recursos opcionales. Una app no trae React ni el SDK; usa los del sistema, y eso la mantiene chica (la app de ejemplo Fractal pesa 5 KB). Se instalan sin root en `~/.local/share/lordos/apps/<id>/`. El instalador rechaza enlaces, dispositivos, rutas absolutas, `..`, caracteres raros, más de 2.000 archivos o 64 MB, y reemplaza la versión anterior de forma atómica. Cada una corre aislada (§6.4).
+
+### 5.3 La Tienda y los paquetes de Debian
+
+La Tienda muestra las apps de Debian por categoría con búsqueda, las apps `.lpk` y los archivos `.deb` locales, y siempre muestra un plan antes de instalar o quitar. Los paquetes de Debian los maneja **el motor de paquetes propio de LordOS** (`server/src/pkg`): lee las fuentes de apt, verifica las firmas de `InRelease` con su propio código OpenPGP (RSA y Ed25519), rechaza índices vencidos, repetidos, de otra suite o con datos agregados al final, verifica cada índice y cada `.deb` contra los valores SHA-256 del índice firmado, y resuelve dependencias (planes idénticos a los de apt en 12 casos de prueba). Solo el último paso es de Debian: `dpkg` desempaqueta y configura, y sigue siendo el único que escribe su base de datos, así `apt` sigue funcionando. LordOS no tiene un cliente TLS propio, así que las fuentes `https://` se descargan por `http://`; la integridad descansa en las firmas y los hashes, pero los nombres de los paquetes descargados quedan visibles en la red.
+
+### 5.4 Apps de Linux
+
+Las apps de Linux con un archivo `.desktop` aparecen en el lanzador de apps. El lanzamiento pasa por `lord.apps.launch(id)`: la interfaz solo puede nombrar un archivo `.desktop` instalado; `lord-server` lo vuelve a leer, lo verifica, arma `argv` a partir de su línea `Exec` según la especificación y lo ejecuta con `execve`, sin shell ni argumentos del llamador, dentro de su propio scope de cgroup que pertenece a root. Chromium y Firefox vienen preinstalados en la ISO y se verificaron con el marco de LordOS. **LordOS no aísla las apps de Linux**; tienen atribución y el firewall por app (§6.6).
+
+### 5.5 WebAssembly
+
+LordOS incluye su propio intérprete de WebAssembly en C (`server/src/wasm`), expuesto como el objeto global estándar `WebAssembly`, así una app nativa puede traer módulos compilados desde C, C++, Rust o Zig. Cubre WebAssembly 2.0 sin SIMD (el MVP más extensión de signo, conversiones saturadas, multi-valor, memoria masiva y tipos de referencia), pasa 26.290 de 26.290 aserciones de la suite oficial de pruebas en la VM, y convierte cada error en un trap en lugar de un fallo. En el ejemplo del proyecto corrió de 3 a 5 veces más rápido que el mismo código en JavaScript.
+
+### 5.6 Instalar LordOS
+
+- **ISO live** para PC de 64 bits, con un instalador gráfico (UEFI y BIOS).
+- **Imagen para Raspberry Pi 5** para tarjeta SD o NVMe (§7.4).
+- **Sobre un Debian 13 existente**: `curl -fsSL https://lordos.org/install.sh | sh`. El script pregunta antes de cambiar nada, descarga `SHA256SUMS` y verifica su firma Ed25519 con la clave de releases embebida en el script, se niega a seguir sin una firma válida, verifica el SHA-256 del `.deb`, lo instala con apt y configura el sistema como la ISO. El repositorio es privado hasta la primera beta pública, así que la ruta de descarga todavía no es pública.
+
+### Archivos fuente
+
+- [apps](https://github.com/lordbasex/LordOS/tree/main/apps), [server/src/lpk.c](https://github.com/lordbasex/LordOS/blob/main/server/src/lpk.c), [tools/lpk.mjs](https://github.com/lordbasex/LordOS/blob/main/tools/lpk.mjs)
+- [server/src/pkg](https://github.com/lordbasex/LordOS/tree/main/server/src/pkg), [server/src/apps.c](https://github.com/lordbasex/LordOS/blob/main/server/src/apps.c)
+- [server/src/wasm/wasm.c](https://github.com/lordbasex/LordOS/blob/main/server/src/wasm/wasm.c), [server/src/ui/js_wasm.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/js_wasm.c)
+- [tools/install/install.sh](https://github.com/lordbasex/LordOS/blob/main/tools/install/install.sh)
+
+## 6. Seguridad
+
+### 6.1 Modelo de amenazas
+
+LordOS está diseñado contra estas amenazas:
+
+- **Una app instalada maliciosa o comprometida** que quiere los archivos, las claves, el micrófono, la cámara, el portapapeles o la red del usuario.
+- **Documentos y mensajes maliciosos**: PDF, archivos comprimidos, fuentes, imágenes, video y correo armados para explotar un lector.
+- **Una app de Linux que quiere sacar datos**, o escaparse de las reglas que se le pusieron.
+- **Un atacante en la red local** que intenta usar el escritorio remoto o alterar descargas.
+- **Paquetes y releases alterados.**
+
+Fuera del modelo, por ahora: un kernel o una cuenta root comprometidos; ataques físicos; canales laterales; y apps de Linux que leen los archivos del usuario (corren como el usuario, como en cualquier Debian). A las apps de Linux se las limita solo en la red.
+
+### 6.2 Mínimo privilegio
+
+- `lord-server` corre como el usuario. En una sesión administrada nunca tiene los dispositivos de pantalla ni de entrada por sí mismo: `lord-sessiond` se los presta y se los revoca.
+- Las bibliotecas que leen datos no confiables las enlazan solo ayudantes: FFmpeg y libva, `lord-media`; Poppler y libarchive, `lord-doc`; OpenSSL, `lord-maild` y `lord-sessiond`; Monocypher, `lord-vault`.
+- Los ayudantes reciben archivos y dispositivos como descriptores abiertos por `lord-server`; nunca abren rutas.
+- El compositor nunca espera a un ayudante ni a una app, así un fallo o un cuelgue queda contenido.
+
+### 6.3 Los procesos root y sus interfaces cerradas
+
+| Proceso | Acepta | Nunca hace |
+|---|---|---|
+| ayudante `admin.c` | una tabla fija de acciones, con argumentos validados como root | acciones genéricas, texto del usuario en una shell |
+| `lord-sessiond` | pedidos de inicio de sesión desde la pantalla de inicio; JSON de sesión corto (≤ 4 KB) | dejar que la pantalla de inicio verifique contraseñas; leer píxeles como root |
+| su hijo de ubicación en cgroups | `enter <scope> <limits>` solo para el proceso que llama, desde la hoja `server` de una sesión, corriendo un binario del directorio de `lord-server` | ubicar procesos arbitrarios; devolverle el árbol al usuario |
+| `lord-netd` | acciones `net-*` solo de pares root | acciones que no son de red; ejecutar nada que venga de una sesión |
+| `lord-netperm` | `RELOAD` sin datos | ejecutar programas; recibir argumentos; abrir sockets de internet |
+| `lord-fand` | `STATUS` para cualquiera; `PROFILE`, `CURVE`, `FORCE` para administradores | nombrar rutas o dispositivos; ejecutar programas; usar la red |
+
+### 6.4 La caja de arena de las apps
+
+Cada app `.lpk`, y la app Contraseñas, corre como `lord-server --app <id>`: el mismo binario en "modo app", lanzado por `lord-server` con un id de paquete validado como único argumento. El proceso se conecta al compositor como cliente Wayland y abre el socket del broker, después aplica la caja de arena, y recién entonces carga el código de la app (`server/src/sec/sandbox.c`):
+
+- **Landlock** (ABI hasta 6): acceso de solo lectura al paquete, al runtime compartido de las apps, a las fuentes y a las bibliotecas; lectura y escritura solo en `~/.local/share/lordos/appdata/<id>`; acotamiento de sockets Unix abstractos y de señales.
+- **seccomp-bpf**: una lista de llamadas al sistema permitidas en todos los hilos (TSYNC), sin `ptrace`, `mount`, `kexec`, `bpf`, `perf_event_open`, `keyctl`, carga de módulos ni `execve`. Se rechazan los sockets Unix nuevos y `socketpair`, porque Landlock hasta la ABI 6 no filtra `connect` a sockets Unix con nombre; así la app queda lejos del bus de sesión, del servicio de impresión y del socket de Wayland.
+- **Sin privilegios**: `no_new_privs`, un conjunto de capacidades vacío y el conjunto límite descartado.
+- **cgroup v2**: `app-lordos-lpk-<id>.scope`, creado por root, con `memory.high` 192 MB, `memory.max` 512 MB y un núcleo de CPU.
+- **Red**: sin el permiso `network` (declarado **y** permitido), seccomp rechaza los sockets de internet y Landlock rechaza connect y bind de TCP. No se usan espacios de nombres de red, porque crear uno necesita privilegios que `lord-server` no tiene.
+
+Si falta una función del kernel, la app arranca igual y el registro dice qué parte falta. La app de prueba maliciosa a propósito (`tests/lpk-evil`) fracasa en todo lo que intenta; `build/sandbox-test` pasa 14 de 14 verificaciones para apps y 14 de 14 con red. Medido en una VM: unos 13,7 MB de RSS por app aislada, un arranque mediano de 106 ms y 0,89 ms para aplicar la caja de arena.
+
+### 6.5 El broker, los permisos y el diálogo de archivos
+
+[[diagram:permission]]
+
+La app aislada habla con `lord-server` solo por un socket `SOCK_SEQPACKET`. Cada pedido se verifica en C: acceso a archivos solo dentro de la carpeta de datos propia de la app; lectura del portapapeles solo con el permiso `clipboard`; pedidos de permiso respondidos según la decisión guardada o, si no hay, con un **aviso dibujado por el sistema** (*Permitir / No permitir*); cámara y micrófono solo a través de `lord-server`.
+
+- **Las decisiones** se guardan por usuario en `~/.config/lordos/permisos.json`, fuera del alcance de la app. La consulta es O(1).
+- **El diálogo de archivos es el powerbox propio de LordOS** (`sdk/powerbox.jsx`), no `xdg-desktop-portal`: lo dibuja `lord-server`, que abre el archivo elegido y pasa solo ese descriptor. La única interfaz de portal de escritorio que implementa LordOS es `org.freedesktop.portal.Settings`, para la apariencia de GTK.
+- **Micrófono:** `lord-server` es dueño del stream de PipeWire y le da a la app un anillo compartido de solo lectura.
+- **Cámara:** `lord-server` abre el dispositivo y se lo da solo a `lord-media`; la app recibe una vista de solo lectura de los cuadros decodificados y tiene que confirmar cada uno, y `lord-server` valida cada confirmación.
+- **Revocación:** denegar la cámara o el micrófono en Ajustes los corta al instante (se mata el `lord-media` de la app; se cierra el stream de PipeWire). El permiso `network` se decide al lanzar la app.
+- **Llavero:** los pedidos al llavero de una app aislada llevan un dueño que `lord-server` fija a partir del id verificado de la app.
+
+**Límites.** No hay "permitir una vez". Algunos permisos declarables (Bluetooth, lanzar apps, notificaciones) todavía no tienen llamada en el broker, así que las apps aisladas directamente no pueden usar esas capacidades; escuchar en un puerto depende del permiso de red. Una app de Linux que corre como el usuario podría editar el archivo de permisos.
+
+### 6.6 El firewall por app y el Monitor
+
+[[diagram:firewall]]
+
+`lord-netperm` aplica las reglas de red por app en el kernel. Las apps de Linux abiertas desde el lanzador de apps corren en `app-lordos-<id>.scope`, las apps `.lpk` en `app-lordos-lpk-<id>.scope`, y el resto de la sesión cuenta como `lordos`. Todos los scopes pertenecen a root. El servicio carga siete programas eBPF de cgroup (`connect4/6`, `sendmsg4/6`, `bind4/6`, `sock_create`) en el cgroup de `lordos.service`, identifica la app de cada proceso por su ancestro de cgroup y devuelve permitir o denegar (`EPERM`). Los programas están compilados dentro del binario y se cargan con un cargador propio de LordOS sobre la llamada al sistema `bpf()`; no se usan libbpf ni bcc.
+
+- **Las reglas** admiten dominios exactos, comodines, redes IPv4/IPv6, `lan`, `internet`, puertos, protocolos y dirección. Primero van las restricciones (sin internet, sin LAN, sin red, sin entrantes); después gana la regla más específica, y denegar le gana a permitir a igual especificidad; después las apps de confianza; después el modo (silencioso, el predeterminado, o apagado). `npcompile.c` precalcula todo esto en mapas hash y de coincidencia por prefijo más largo. Una prueba corre el código de decisión del kernel contra el decisor de referencia sobre 480.000 conexiones aleatorias: 0 diferencias.
+- **Los nombres de dominio** vienen solo del resolvedor del sistema: la interfaz de monitoreo de systemd-resolved o, sin él, las respuestas del puerto 53 de los servidores configurados, leídas por un socket de paquetes que solo recibe. Nunca se confía en respuestas que una app recibió por sus propios sockets.
+- **Escapes.** El árbol de cgroups pertenece a root, así que una app no puede moverse sola. Un proceso que le pide al gestor de systemd del usuario una unidad nueva (`systemd-run --user`) termina bajo `user@<uid>.service`; `lord-netperm` engancha los mismos programas ahí y somete esos procesos a la unión más estricta de las apps restringidas en ejecución de ese usuario. Probado: todos los intentos de escape denegados, los otros usuarios sin afectar.
+- **Costo**: alrededor de 0,5 µs por connect de UDP, TCP dentro del ruido, sin cambio en el rendimiento, porque nada corre por paquete.
+- **El Monitor** muestra las conexiones de cada app (desde `sock_diag`), los bytes, los destinos por país desde una base de datos local y un interruptor de Regla por app. Ninguna dirección sale de la máquina para consultas: sin DNS inverso, sin geolocalización en línea.
+
+**Límites.** El modo "preguntar" está diseñado pero hoy se comporta como silencioso. Todavía no hay interfaz para reglas por dominio ni interruptores por destino (el motor y la API las soportan). ICMP se bloquea solo con "sin red"; las conexiones a un puerto ya abierto no se verifican. Ajustes también ofrece restricciones que no son de red (cámara, micrófono, pantalla, USB, Bluetooth, archivos, notificaciones): se guardan, pero **ningún componente las aplica todavía**.
+
+### 6.7 Ayudantes que procesan datos no confiables
+
+[[diagram:helpers]]
+
+`lord-doc` (PDF, archivos comprimidos, fuentes, imágenes del escáner), `lord-media` (video, audio, fotos, cámara), `lord-maild` (correo, calendarios, contactos) y `lord-vault` (secretos) comparten una caja de arena endurecida, `sandbox_apply_helper()`:
+
+- sin `socket`, `socketpair`, `connect`, `bind`, `listen`, `accept`; sin `execve`; `clone` solo para hilos; seccomp en todos los hilos, y si seccomp no se puede aplicar el ayudante termina;
+- archivos solo a través de descriptores que pasa `lord-server`; ioctls solo por clase (DRM, V4L2, DMA-BUF) donde hace falta;
+- resultados devueltos en memoria compartida sellada, validada por `lord-server`.
+
+`lord-media` ni siquiera recibe el socket de PipeWire; el audio pasa por un anillo compartido cuyo stream es de `lord-server`. `lord-maild` no puede crear sockets: se lo pide a `lord-server`, que conecta solo con los servidores del archivo de cuentas (y, después de que el usuario pide cargar imágenes, solo con direcciones públicas en los puertos 80/443 durante diez minutos) y le entrega el socket conectado. `build/sandbox-test helper` pasa 17 de 17 verificaciones.
+
+### 6.8 Firma de paquetes y niveles de confianza
+
+Los paquetes `.lpk` llevan un manifiesto con el SHA-256 de cada archivo y una firma Ed25519 sobre él. SHA-256 y Ed25519 son código propio de LordOS (Ed25519 siguiendo la aritmética de TweetNaCl), probado contra los vectores del NIST y del RFC 8032 (55 de 55). La verificación ocurre en C al instalar y al cargar. La Tienda muestra el nivel de confianza: **LordOS** (clave oficial, compilada dentro del binario para que ningún archivo pueda agregar otra), **Autor verificado** (listado en el catálogo firmado), **Firmado por <nombre>**, o **Sin firmar** con una advertencia. Las actualizaciones tienen que estar firmadas con la misma clave. Un catálogo firmado lleva una lista de revocación. Si editás una app instalada, LordOS la marca "Modificada por vos", puede restaurar la original o compartir tu versión firmada con tu propia clave, con crédito al original.
+
+**Estado:** hoy los paquetes oficiales se firman con una clave de desarrollo; la clave final la reemplaza para el lanzamiento público. Todavía no está construido un repositorio firmado de apps de LordOS para la Tienda.
+
+### 6.9 Firma de releases
+
+Cada archivo de release (el `.deb`, la ISO y la imagen para Raspberry Pi) aparece con su SHA-256 en `SHA256SUMS`, y `SHA256SUMS` está firmado con la clave de releases de LordOS (Ed25519). La clave pública es `tools/release/lordos-release.pub.pem`, también embebida en el instalador para Debian. Su huella (SHA-256 de la clave pública en DER) es:
+
+`c7155b8e6bbbb180f907381994d06af76d333016cd6f3facf67cadd053ea108e`
+
+La clave privada vive solo en la máquina del mantenedor, nunca en el repositorio ni en una máquina de compilación. La §11 muestra cómo verificar una descarga.
+
+### 6.10 La bóveda
+
+`lord-vault` guarda las contraseñas y el llavero de la sesión en archivos `.lvault`: una clave de bóveda aleatoria de 32 bytes, envuelta una vez por cada método de desbloqueo (contraseña con Argon2id con un costo calibrado por máquina, FIDO2 `hmac-secret` con el cliente CTAP2 propio de LordOS, archivo llave, contraseña más archivo llave, clave de recuperación); contenido sellado con XChaCha20-Poly1305 con todo el encabezado como datos asociados; adjuntos sellados por separado; guardado atómico con copia de respaldo. Se detecta cada byte invertido y cada truncamiento (1.165 de 1.165 en la prueba). Los secretos viven en un área de memoria con `mlock`, excluida de los volcados de memoria y borrada al liberarse, en un proceso que no se puede volcar. La ventana de Contraseñas corre en su propio proceso aislado, así los valores revelados nunca entran al JavaScript del escritorio. El llavero se abre al iniciar sesión con la contraseña que verificó `lord-sessiond`, y atiende a las apps de Linux mediante la implementación propia de LordOS del Secret Service. Las llaves de seguridad de hardware reales todavía no se probaron.
+
+### 6.11 Ventanas protegidas
+
+Una ventana marcada como protegida (Contraseñas lo está) se pinta en negro en todos los caminos que copian píxeles hacia afuera: capturas, grabaciones, miniaturas, el escritorio remoto, y los menús y la pantalla completa de Wayland. El monitor real la muestra normalmente. Las apps de Linux, para empezar, no tienen ningún protocolo de captura de pantalla.
+
+### Archivos fuente
+
+- [server/src/sec/sandbox.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/sandbox.c), [server/src/sec/brokersrv.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/brokersrv.c), [server/src/sec/perms.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/perms.c), [server/src/sec/cgroup.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/cgroup.c)
+- [server/src/netperm/np.bpf.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/np.bpf.c), [server/src/netperm/netperm.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/netperm.c), [server/src/fw/rules.c](https://github.com/lordbasex/LordOS/blob/main/server/src/fw/rules.c)
+- [server/src/sec/sign.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/sign.c), [server/src/pkg/crypto.c](https://github.com/lordbasex/LordOS/blob/main/server/src/pkg/crypto.c), [tools/release/sign-release.sh](https://github.com/lordbasex/LordOS/blob/main/tools/release/sign-release.sh)
+- [server/src/vault/vault.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/vault.c), [server/src/vault/vfile.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/vfile.c)
+- [server/src/media/capture.c](https://github.com/lordbasex/LordOS/blob/main/server/src/media/capture.c)
+
+## 7. Rendimiento
+
+Todas las cifras de abajo las midió el proyecto y están documentadas en los archivos citados. La mayoría vienen de máquinas virtuales; las mediciones en hardware real se indican como tales.
+
+### 7.1 Memoria y reposo
+
+| Medición | Valor | Dónde |
+|---|---|---|
+| Sistema completo, ISO live, en reposo después de un minuto (4 GB, 4 núcleos) | 465 MB usados, CPU 99 % ociosa | VM 117, `docs/ISO.md` |
+| Sistema completo, instalado desde la ISO, en reposo | 487 MB usados, CPU 99 % ociosa | VM 120, `docs/ISO.md` |
+| Arranque, ISO live con UEFI | 16,3 s (4,9 s kernel + 11,4 s espacio de usuario) | VM 117, `docs/ISO.md` |
+| `lord-server` sin placa 3D (Mesa sin cargar) | unos 32 MB de RSS | `docs/GPU.md` |
+| Una sesión de usuario (`lord-server`), pruebas de escritorio remoto | unos 50 MB; pantalla de inicio 41 MB | VM 118, `docs/REMOTE.md` |
+| Una app `.lpk` aislada | 13,7 MB de RSS | VM 122, `docs/PRIVACY.md` |
+
+### 7.2 Dibujo
+
+- Arrastrar una ventana en una pantalla de 1280×800 por el camino de CPU: unos 6,7–6,9 ms de trabajo por cuadro, alrededor de 120 cuadros por segundo (VM 118, `docs/DISPLAYS.md`).
+- La misma ventana en una pantalla de 2560×1600 al 150 %: unos 5,1 ms por cuadro.
+- Video: pintar directamente desde el cuadro decodificado cuando solo cambió un video opaco bajó `lord-server` del 42 % al 13 % de un núcleo para un video 1080p en ventana, y del 92 % al 15 % a pantalla completa (`docs/ROADMAP.md`, multimedia).
+- El Monitor cerrado no cuesta nada: su hilo de muestreo no existe hasta que se abre (`docs/MONITOR.md`).
+
+### 7.3 GPU
+
+En las VM solo había un renderizador por software. Con él, el camino de CPU es más barato que la composición "por GPU", y por eso LordOS usa el camino de CPU cuando el único renderizador es por software. El beneficio real del camino por GPU (composición y presentación casi gratis, pantalla completa sin copias) se espera en placas reales, pero **todavía no se midió en hardware AMD ni Nvidia real**.
+
+### 7.4 La Raspberry Pi 5
+
+La Raspberry Pi 5 es la única placa soportada. Resultados en una placa real (16 GB, tarjeta SD, sin monitor), de `docs/RASPBERRY.md`:
+
+| Medición | Valor |
+|---|---|
+| Compilar todos los binarios de LordOS en la placa | 1 min 02 s, 0 advertencias |
+| `make -C server test` | 23 pasaron, 0 fallaron, 0 omitidas |
+| Copias y máscaras NEON vs. C puro | 9,90 → 4,33 ms y 11,09 → 5,49 ms por pantalla (2,0–2,3×), idénticas bit a bit |
+| En reposo en la pantalla de inicio, sin monitor | `lord-server` 36 MB de RSS, 0,6 % de CPU; sistema 450 MB de 16 GB; 38–43 °C, sin limitación térmica |
+| Armar la imagen SD en la placa | 8 min 18 s; 503 MB comprimida |
+| Compilar el kernel de LordOS en la placa | unos 50 min por variante |
+
+**El kernel de LordOS.** El kernel propio de Raspberry Pi no compila Landlock. Sin él, la prueba hostil del ayudante de documentos falla 5 de sus 25 verificaciones de sistema de archivos y la prueba de la caja de arena no puede correr. LordOS compila el kernel de Raspberry Pi desde su propio código fuente y configuración predeterminada, cambiando solo tres opciones (Landlock activado, la lista de LSM, el sufijo de versión), y lo fija para que un kernel más nuevo del archivo no pueda reemplazarlo. La imagen también activa el cgroup de memoria, que Raspberry Pi apaga al arrancar.
+
+**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`).
+
+**Todavía no verificado en la placa:** todo lo que requiere un monitor conectado (configuración de modos, composición por GPU en pantalla, cuadros por segundo), la sesión de escritorio y arrancar la imagen generada.
+
+### 7.5 PC modernas
+
+Todavía no hay mediciones en PC reales en el repositorio. La ISO se prueba en máquinas virtuales (UEFI y BIOS); está planeado probarla en una máquina AMD real desde el USB live.
+
+### Archivos fuente
+
+- [docs/ISO.md](https://github.com/lordbasex/LordOS/blob/main/docs/ISO.md), [docs/RASPBERRY.md](https://github.com/lordbasex/LordOS/blob/main/docs/RASPBERRY.md), [docs/FANS.md](https://github.com/lordbasex/LordOS/blob/main/docs/FANS.md), [docs/DISPLAYS.md](https://github.com/lordbasex/LordOS/blob/main/docs/DISPLAYS.md)
+- [tools/rpi/build-kernel.sh](https://github.com/lordbasex/LordOS/blob/main/tools/rpi/build-kernel.sh), [tools/rpi/build-img.sh](https://github.com/lordbasex/LordOS/blob/main/tools/rpi/build-img.sh)
+- [server/src/canvas.c](https://github.com/lordbasex/LordOS/blob/main/server/src/canvas.c)
+
+## 8. Experiencia visual
+
+- **Una guía de diseño.** Las apps siguen una guía común (`docs/DESIGN.md`): una grilla de espaciado de 8 px, una escala tipográfica chica, alturas de controles consistentes y una sola acción con el color de acento por vista. El SDK exporta los tokens (`spacing`, `typeScale`, `controlSize`), y cada app pasó por rondas de pulido documentadas con capturas de antes y después en claro, oscuro, de derecha a izquierda y en ventanas chicas.
+- **Temas.** Un tema es un escritorio completo escrito en React: barra de menú, Dock, lanzador de apps, Centro de control y marco de ventana, más sus tokens. LordOS trae un tema predeterminado con barra de menú y Dock, y un tema Clásico con barra de tareas y menú de inicio. Los temas cambian en vivo; la configuración se conserva.
+- **Claro y oscuro, acentos.** Los dos modos y el color de acento se aplican en vivo a las apps nativas, a las apps aisladas y, a través del portal y de GSettings, a las apps GTK.
+- **De derecha a izquierda.** Toda la interfaz se espeja para el árabe, el hebreo y escrituras similares, incluidas las apps aisladas, que siguen en vivo el idioma de la sesión.
+- **Lumo.** La mascota de LordOS es Lumo, un pequeño zorro celestial, que aparece en pantallas de bienvenida, estados vacíos y material de marca, con un conjunto fijo de poses definido en la guía de marca.
+- **Accesibilidad hoy:** una opción "Reducir movimiento" que apaga las animaciones decorativas, atajos de teclado en todo el sistema y pantallas escalables hasta el 200 %. Un lector de pantalla, zoom y alto contraste están en la hoja de ruta y **todavía no están construidos**.
+
+### Archivos fuente
+
+- [docs/DESIGN.md](https://github.com/lordbasex/LordOS/blob/main/docs/DESIGN.md), [docs/LORDOS-BRAND.md](https://github.com/lordbasex/LordOS/blob/main/docs/LORDOS-BRAND.md)
+- [themes](https://github.com/lordbasex/LordOS/tree/main/themes), [sdk/controls.jsx](https://github.com/lordbasex/LordOS/blob/main/sdk/controls.jsx), [sdk/i18n.js](https://github.com/lordbasex/LordOS/blob/main/sdk/i18n.js)
+
+## 9. Extensibilidad
+
+- **El SDK** (`@lordos/sdk`) es lo único que importan las apps: ventanas, configuración, tokens del tema, controles, archivos, multimedia, notificaciones, llavero, impresión y más. Las apps no importan nada de los temas, así cualquier app funciona en cualquier tema.
+- **Escribir una app** es una carpeta con `manifest.json` e `index.jsx`. `node tools/lpk.mjs <folder>` la empaqueta sin React ni el SDK, agrega el ícono y las traducciones, y la firma si se le da una clave; `keygen`, `sign`, `verify` y `catalog` cubren el resto. Las apps pueden incluir módulos de WebAssembly y dibujar píxeles crudos con `<Image pixels>`.
+- **Los temas** siguen un contrato fijo (`Desktop`, `MenuBar`, `Dock`, `Launcher`, `ControlCenter`, `WindowFrame`, tokens), documentado en `themes/README.md`, con el tema Clásico como plantilla.
+- **La interoperabilidad con Linux** pasa por estándares: Wayland, el portal de configuración, el Secret Service, el servicio de notificaciones, las apps predeterminadas de `mimeapps.list` y los archivos `.desktop`.
+- **Automatización:** hoy no hay ninguna API de scripting ni de automatización más allá del SDK. Las integraciones con asistentes de IA (por ejemplo a través del Model Context Protocol) **no existen en LordOS**; son solo una posible dirección futura y tendrían que respetar la misma regla de que el JavaScript no puede ejecutar comandos.
+
+### Archivos fuente
+
+- [sdk](https://github.com/lordbasex/LordOS/tree/main/sdk), [apps/README.md](https://github.com/lordbasex/LordOS/blob/main/apps/README.md), [themes/README.md](https://github.com/lordbasex/LordOS/blob/main/themes/README.md)
+- [docs/NATIVE-APPS.md](https://github.com/lordbasex/LordOS/blob/main/docs/NATIVE-APPS.md), [docs/WASM.md](https://github.com/lordbasex/LordOS/blob/main/docs/WASM.md), [examples/apps/fractal](https://github.com/lordbasex/LordOS/tree/main/examples/apps/fractal)
+
+## 10. Hoja de ruta y limitaciones
+
+### 10.1 Dónde estamos
+
+Los hitos M1 a M9 están completos en la 0.7.0 Beta: el servidor gráfico, el motor de interfaz, el SDK y los temas, la terminal, los idiomas y las escrituras complejas, la compatibilidad con apps de Linux, los paquetes y los servicios del sistema, las sesiones, el aislamiento y el firewall, y las suites de apps de M9 (documentos e impresión, multimedia, apps del sistema, contraseñas, configuración de hardware, correo y calendario). La ISO final se armó y se probó en máquinas virtuales el 18 de octubre de 2026.
+
+### 10.2 Limitaciones conocidas
+
+- Hardware real: no se probaron GPU AMD y Nvidia, monitores reales, notebooks (batería, brillo, tapa), controladores Bluetooth, impresoras y escáneres, llaves FIDO2 ni proveedores de correo reales.
+- La Raspberry Pi 5 no se probó con un monitor, y su imagen generada todavía no se arrancó.
+- Las apps de Linux no están aisladas; no hay Xwayland.
+- Firewall: sin modo "preguntar", sin interfaz para reglas por dominio, restricciones que no son de red sin aplicar.
+- Permisos: no hay "permitir una vez"; no se muestra el uso de cámara y micrófono por parte de apps de Linux.
+- Hay que desactivar Secure Boot; la firma con un shim está pendiente.
+- Las descargas de paquetes usan HTTP (firmadas y con hash).
+- El escritorio remoto no tiene audio.
+- La accesibilidad (lector de pantalla, zoom, alto contraste) no está construida.
+
+### 10.3 Lo que viene
+
+Antes del lanzamiento final: la ISO final con todo y una imagen para Raspberry Pi 5 probada en la placa real. Después, según lo planeado en `docs/ROADMAP.md`: una app de virtualización de escritorio construida sobre KVM y QEMU; un contenedor Android con LineageOS y apps desde la Tienda de LordOS; el modo "preguntar" del firewall; accesibilidad; y un video de demostración completo.
+
+### Archivos fuente
+
+- [docs/ROADMAP.md](https://github.com/lordbasex/LordOS/blob/main/docs/ROADMAP.md), [CHANGELOG.md](https://github.com/lordbasex/LordOS/blob/main/CHANGELOG.md)
+
+## 11. Cómo verificar el proyecto por tu cuenta
+
+### 11.1 Compilalo
+
+En una máquina de desarrollo con Node.js, empaquetá los temas, el SDK y las apps:
+
+```
+npm install && npm run build
+```
+
+En Debian 13, compilá los binarios y corré las pruebas:
+
+```
+sudo apt-get install -y --no-install-recommends build-essential
+make -C server -j4
+make -C server test # every self-contained suite
+make -C server test-full # adds the helpers, the sandbox and the HarfBuzz comparison
+```
+
+`make test` falla si falla cualquier suite; una suite cuya herramienta o datos no están instalados informa "skipped" en lugar de pasar en silencio. Las pruebas de la caja de arena necesitan un kernel con Landlock. La ISO y la imagen para Raspberry Pi se arman como se describe en `docs/ISO.md` y `docs/RASPBERRY.md`.
+
+### 11.2 Qué cubren las pruebas
+
+- **Terminal y texto:** el emulador VT, el shaping OpenType contra HarfBuzz, el bidi Unicode contra el archivo de prueba oficial, los métodos de entrada y la separación de palabras en tailandés contra libthai.
+- **Seguridad:** la caja de arena (app, red, ayudante), la firma (vectores del NIST y del RFC 8032), el estado de los paquetes, las reglas de rutas de archivos comprimidos contra archivos maliciosos, las protecciones de `lord.fs`, las reglas del firewall (con 20.000 mutaciones de JSON y 30.000 operaciones aleatorias contra una referencia lineal), el lector DNS (200.000 paquetes aleatorios), el compilador de mapas del kernel (480.000 conexiones) y la prueba de integración con el kernel (18 de 18 en una VM).
+- **Lectores:** correo, MIME, sanitizador de HTML, iCalendar, vCard y XML (30.953 verificaciones con fuzzing por mutación), el formato de la bóveda, los importadores, QR, CBOR, la serialización de D-Bus, el lector de la base de países, el journal, TZif e IPP.
+- **Motor y hardware:** layout y pintado, NEON vs. C, el driver de touchpad con gestos grabados, ventiladores sobre árboles sysfs falsos, la disposición de pantallas, el sonido y la suite de la especificación de WebAssembly.
+
+En la compilación de la ISO final: `make -C server test` informó 23 pasaron, 0 fallaron, 1 omitida (faltaban los datos de bidi).
+
+### 11.3 Verificá un release
+
+Descargá `SHA256SUMS`, `SHA256SUMS.sig`, los archivos del release y la clave pública (`tools/release/lordos-release.pub.pem`). Comprobá que la huella de la clave sea `c7155b8e6bbbb180f907381994d06af76d333016cd6f3facf67cadd053ea108e` y después, con OpenSSL 3:
+
+```
+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
+```
+
+### 11.4 Verificá un sistema en marcha
+
+- `systemctl status lord-netperm lord-fand lordos` muestra los servicios; la prueba de la ISO confirmó siete programas BPF enganchados.
+- `cat /proc/<pid>/status | grep -E 'Seccomp|NoNewPrivs'` sobre un proceso `lord-server --app` muestra la caja de arena.
+- `systemd-cgls` muestra el árbol `lordos-session-<uid>`, de root, con un scope por app.
+- Escritorio remoto: `ss -ltn` no muestra nada en el puerto 5673 hasta que lo activás en Ajustes → Compartir.
+
+## 12. Licencia y créditos
+
+El código de LordOS se publica bajo la **licencia MIT**. Los componentes de terceros conservan sus propias licencias, listadas en `THIRD_PARTY.md`: QuickJS y stb (incluidos como código fuente), Monocypher (CC0/BSD-2), la lista de palabras de la EFF (CC BY 3.0 US), la lista de contraseñas comunes (MIT), los datos de países de DB-IP Lite (CC BY 4.0), Natural Earth (dominio público) y las fuentes Inter, JetBrains Mono y Plus Jakarta Sans (OFL).
+
+LordOS lo crea el grupo **IPERFEX**: **Pablo Miranda** y **Federico Pereira**.
+
+## 13. Glosario
+
+- **Broker:** el único socket por el que una app aislada le pide a `lord-server` cualquier cosa que toque las cosas del usuario; cada pedido se verifica en C.
+- **cgroup (v2):** un mecanismo del kernel que agrupa procesos para contabilizar y limitar recursos. LordOS le da a cada app su propio grupo, un "scope", y lo usa para identificar la app en el firewall.
+- **Compositor:** el programa que combina las ventanas de todas las apps en la imagen final de la pantalla.
+- **DRM/KMS:** las interfaces del kernel para los dispositivos gráficos y para configurar los modos de pantalla.
+- **eBPF:** programas pequeños y verificados que corren dentro del kernel; LordOS los engancha a cgroups para decidir sobre las conexiones de red.
+- **evdev:** la interfaz del kernel para los dispositivos de entrada.
+- **Ayudante:** un proceso chico de LordOS que maneja datos no confiables o secretos en una caja de arena más estricta (`lord-doc`, `lord-media`, `lord-maild`, `lord-vault`).
+- **Landlock:** una función del kernel que permite que un proceso sin privilegios restrinja qué archivos y puertos de red puede usar él, y sus hijos.
+- **`.lpk`:** el formato de paquete de LordOS para apps nativas instalables.
+- **`.lvault`:** el formato de archivo de bóveda cifrada de LordOS.
+- **Powerbox:** un diálogo de archivos dibujado por el sistema que le da a la app solo el archivo que eligió el usuario.
+- **QuickJS:** un motor de JavaScript chico escrito en C.
+- **Scope:** un cgroup para una app, como `app-lordos-lpk-<id>.scope`.
+- **seccomp-bpf:** un filtro del kernel que restringe qué llamadas al sistema puede hacer un proceso.
+- **Secret Service:** el estándar de D-Bus de freedesktop que usan las apps de Linux para guardar secretos.
+- **Wayland:** el protocolo entre las apps gráficas y el compositor.
+
+## 14. Dónde leer más
+
+| Capítulo | Documentos en `docs/` |
+|---|---|
+| 1. Visión | ARCHITECTURE.md, LORDOS-BRAND.md |
+| 2. Arquitectura | ARCHITECTURE.md, NETWORK.md, FANS.md, SETTINGS.md, SYSTEM.md |
+| 3. Compositor | GPU.md, DISPLAYS.md, WINDOWS.md, TRACKPAD.md, WAYLAND.md, SESSIONS.md, REMOTE.md |
+| 4. Motor de interfaz | ARCHITECTURE.md, LANGUAGES.md, TERMINAL.md |
+| 5. Aplicaciones | NATIVE-APPS.md, PACKAGES.md, WASM.md, FILES.md, MEDIA.md, DOCUMENTS.md, MAIL.md, ISO.md, INSTALL-DEBIAN.md |
+| 6. Seguridad | PRIVACY.md, FIREWALL.md, MONITOR.md, SIGNING.md, PASSWORDS.md, MEDIA.md, REMOTE.md |
+| 7. Rendimiento | ISO.md, RASPBERRY.md, FANS.md, DISPLAYS.md, GPU.md |
+| 8. Experiencia visual | DESIGN.md, LORDOS-BRAND.md, LANGUAGES.md, DOCK.md |
+| 9. Extensibilidad | NATIVE-APPS.md, WASM.md, y `apps/README.md`, `themes/README.md` |
+| 10. Hoja de ruta | ROADMAP.md y `CHANGELOG.md` |
diff --git a/web/content/paper/paper.pt.md b/web/content/paper/paper.pt.md
new file mode 100644
index 0000000..47d9c20
--- /dev/null
+++ b/web/content/paper/paper.pt.md
@@ -0,0 +1,534 @@
+## Resumo
+
+O LordOS é uma distribuição GNU/Linux livre baseada no Debian 13 que traz um ambiente de desktop próprio, construído a partir dos seus componentes fundamentais sobre Debian e Wayland. Em vez do GNOME ou do KDE, ele tem seu próprio servidor gráfico e compositor Wayland escritos em C (`lord-server`), seu próprio motor de interface (React rodando sobre o motor JavaScript QuickJS, com layout, pintura e texto em código C nativo), seus próprios apps nativos e seus próprios serviços de segurança: um lançador de apps em sandbox, um broker de permissões, um armazenamento de permissões por app, um firewall por app aplicado pelo kernel, assinatura de pacotes e um cofre de senhas criptografado. Ele reaproveita o que é maduro e amplamente revisado: o kernel Linux, o Debian e seus pacotes, Mesa, PipeWire, o protocolo Wayland e algumas bibliotecas (FFmpeg, Poppler, libarchive, OpenSSL, Monocypher) confinadas em pequenos processos ajudantes em sandbox.
+
+Este documento descreve o projeto e o estado atual da versão **0.7.0 Beta** (outubro de 2026) para um leitor técnico que quer conferir o projeto em vez de acreditar nele. Cada afirmação aponta para um arquivo no repositório público. Os números são os medidos nos registros de teste do projeto e indicam onde foram medidos. O que está projetado mas não construído está marcado como tal.
+
+## 1. Visão
+
+### 1.1 O problema
+
+Um desktop Linux moderno é montado a partir de muitos projetos independentes: um servidor gráfico ou compositor, um toolkit, um gerenciador de sessão, um daemon de configurações, um chaveiro, um gerenciador de rede, uma interface de firewall e os apps. Cada um é bom no que faz, mas é nas emendas entre eles que as coisas ficam lentas, inconsistentes ou inseguras. Três emendas em especial motivaram o LordOS:
+
+- **Peso.** Um desktop que desenha sua interface com um motor web, ou que carrega vários toolkits ao mesmo tempo, precisa de centenas de megabytes antes de o usuário abrir qualquer coisa. O LordOS quer ser confortável em máquinas modestas e num Raspberry Pi 5.
+- **Confiança nos apps.** Num desktop Linux tradicional, todo programa que o usuário roda pode ler a pasta pessoal inteira, gravar o microfone, abrir qualquer conexão de rede e ler a área de transferência. O sandbox existe, mas costuma ser um complemento que o próprio desktop não entende.
+- **Visibilidade.** O usuário raramente vê qual app está falando com qual servidor, e mais raramente ainda consegue dizer "este app não pode usar a internet" de um jeito que o app não consiga contornar.
+
+### 1.2 Princípios
+
+O projeto segue uma lista curta de regras, escritas em `AGENTS.md` e `docs/ARCHITECTURE.md`:
+
+1. **Ser dono das partes que o usuário toca; reaproveitar a fundação.** O servidor gráfico, o compositor, o motor de interface, os apps e os serviços de segurança são código do LordOS. O kernel, os pacotes do Debian, Mesa, PipeWire e o protocolo Wayland são reaproveitados.
+2. **Uma política de dependências rígida.** X11, wlroots, libdrm, libinput, WebKit, GTK e Qt não são usados dentro do LordOS. Bibliotecas que leem dados não confiáveis só são linkadas por ajudantes em sandbox, nunca pelo compositor.
+3. **A interface não executa comandos.** O JavaScript do LordOS não tem API para executar programas arbitrários. Há três exceções estreitas e sem argumentos (o shell de login do Terminal, abrir um app `.desktop` instalado e iniciar um app `.lpk` instalado no seu sandbox).
+4. **Root só por portas fechadas.** Tudo o que precisa de root passa por uma tabela fixa de ações validadas ou por um pequeno serviço dedicado com protocolo fechado.
+5. **O caminho pela CPU sempre tem que funcionar.** A composição na GPU é uma otimização, nunca um requisito.
+6. **O compositor nunca espera.** Ajudantes, apps e serviços falam com o `lord-server` por sockets não bloqueantes; um app travado trava só a si mesmo.
+7. **Verificar num sistema real.** Cada marco é conferido numa máquina virtual com capturas de tela reais antes de ser dado como pronto, e compatibilidade que não foi testada não é anunciada.
+
+### Arquivos-fonte
+
+- [AGENTS.md](https://github.com/lordbasex/LordOS/blob/main/AGENTS.md)
+- [docs/ARCHITECTURE.md](https://github.com/lordbasex/LordOS/blob/main/docs/ARCHITECTURE.md)
+
+## 2. Arquitetura
+
+### 2.1 Camadas
+
+[[diagram:layers]]
+
+De baixo para cima:
+
+- **O kernel Linux** fornece DRM/KMS para as telas, evdev para a entrada e os recursos de segurança sobre os quais o LordOS se apoia: Landlock, seccomp-bpf, cgroups v2 e eBPF. Em PCs é o kernel do Debian; no Raspberry Pi 5 é a compilação do LordOS do kernel do Raspberry Pi com Landlock ativado (§7.4).
+- **O Debian 13** fornece o espaço de usuário: `dpkg` e o repositório de pacotes, systemd, Mesa, PipeWire, `libwayland`, `libxkbcommon`, CUPS, BlueZ e o resto.
+- **O `lord-server`** é o servidor gráfico e compositor Wayland. Ele controla telas e entrada diretamente, faz a composição e serve o protocolo Wayland para os apps Linux.
+- **O motor de interface** mora dentro do `lord-server`: o QuickJS roda a interface em React, e código C nativo faz layout, pintura e texto.
+- **Os apps** são de três tipos: os apps incluídos e o tema, que rodam no contexto JavaScript do `lord-server`; os apps `.lpk` instalados, cada um no seu próprio processo em sandbox com sua própria instância do motor; e os apps Linux, que se conectam ao compositor como clientes Wayland comuns.
+
+### 2.2 Processos e privilégios
+
+[[diagram:processes]]
+
+Um LordOS em execução tem poucos processos, com papéis bem separados:
+
+| Processo | Roda como | Papel |
+|---|---|---|
+| `lord-sessiond` | root | tela de login, sessões, empréstimo da tela e da entrada para a sessão visível, área de trabalho remota |
+| `lord-netd` | root | a rede do sistema: DHCP, Wi-Fi, VPN; só as ações `net-*` |
+| `lord-netperm` | root (capacidades limitadas) | regras de rede por app, aplicadas com eBPF em cgroups |
+| `lord-fand` | root (sem capacidades) | controle das ventoinhas pela temperatura |
+| `lord-server` | o usuário | um por sessão: compositor, motor de interface, broker |
+| `lord-server --app <id>` | o usuário, em sandbox | um por app `.lpk` em execução (e Senhas) |
+| `lord-doc`, `lord-media`, `lord-maild`, `lord-vault` | o usuário, em sandbox | ajudantes que processam dados não confiáveis ou segredos |
+| tela de login | `lordos-greeter` | desenha a interface de login; nunca verifica senhas por conta própria |
+
+Cada processo root tem uma interface estreita e documentada. A §6.3 descreve cada uma.
+
+### 2.3 O que é nosso e o que é reaproveitado
+
+| Nosso (neste repositório) | Reaproveitado |
+|---|---|
+| Servidor gráfico e compositor Wayland (C) | Kernel Linux |
+| Motor de interface: nós nativos, layout flexbox, rasterizador, shaping de texto, bidi, métodos de entrada | Debian 13 e seus pacotes; `dpkg` |
+| Renderizador React (configuração de host para o `react-reconciler`) | React 19.3.1, `react-reconciler` 0.34 (empacotados no tema) |
+| Apps nativos e temas | QuickJS 2025-04-26 (incorporado como código-fonte) |
+| Sandbox, broker, permissões, assinatura, serviço de firewall, cofre | Mesa (opcional), PipeWire, `libwayland`, `libxkbcommon` |
+| Gerenciador de sessão, serviço de rede, serviço de ventoinhas | systemd, systemd-resolved, BlueZ, CUPS, wpa_supplicant, OpenVPN, o daemon do strongSwan |
+| Motor de pacotes Debian (OpenPGP, xz, HTTP, resolvedor) | FFmpeg, Poppler, libarchive, OpenSSL, Monocypher (só nos ajudantes) |
+| Driver de touchpad, emulador de terminal, interpretador WebAssembly | stb (fontes e imagens), fontes sob a OFL |
+
+O LordOS conversa com vários serviços do Debian pelos protocolos deles, com clientes próprios: D-Bus (BlueZ, perfis de energia, data e hora), IPP (CUPS), o protocolo do PulseAudio (PipeWire) e o Secret Service. libdbus, sd-bus, libcups, libpulse, libbpf e libapt não são usados.
+
+### 2.4 Serviços do sistema
+
+- **Rede (`lord-netd`).** A rede pertence ao sistema, não a uma sessão. O `lord-sessiond` inicia o `lord-netd` no boot, com caminho fixo e sem argumentos, para que a máquina tenha endereço antes de alguém fazer login. Ele roda só as ações fechadas `net-*`: seu próprio cliente DHCP e código netlink, Wi-Fi pelo `wpa_supplicant` do Debian, WireGuard pelo código netlink próprio do LordOS, OpenVPN, IPsec/IKEv2 pelo `charon` do strongSwan controlado via VICI com cliente próprio do LordOS e, opcionalmente, túneis OpenConnect, PPTP e compatíveis com Fortinet. Ele só fala com os ajudantes root das sessões, por um socket que aceita apenas uid 0.
+- **Ventoinhas (`lord-fand`).** Um serviço root que lê a temperatura da CPU a cada 2 s e escreve o ciclo das ventoinhas a partir de um perfil, desde o início do boot. Ele só controla ventoinhas que a própria varredura encontrou: o conector de ventoinha do Raspberry Pi 5 e controladores de placa-mãe de uma lista permitida. Ventoinhas de notebook, de GPU e desconhecidas nunca são escritas. Ao parar, ou depois de uma falha, ele restaura as configurações originais do kernel. Não roda programas, não tem rede, nem capacidades, nem nós de dispositivo.
+- **Configurações de hardware.** Telas (modos vindos do KMS com nomes do EDID, reversão de 15 segundos com "manter estas configurações?", persistência por tela, rotação, Luz Noturna), Bluetooth pelo BlueZ, bateria e perfis de energia, ociosidade e tampa, data e hora, notificações dos apps Linux e apps padrão. As mudanças chegam como uevents do kernel e sinais D-Bus; nada fica consultando em loop.
+
+### Arquivos-fonte
+
+- [server/src/main.c](https://github.com/lordbasex/LordOS/blob/main/server/src/main.c)
+- [server/src/admin.c](https://github.com/lordbasex/LordOS/blob/main/server/src/admin.c)
+- [server/src/net/netd.c](https://github.com/lordbasex/LordOS/blob/main/server/src/net/netd.c)
+- [server/src/fan/fand.c](https://github.com/lordbasex/LordOS/blob/main/server/src/fan/fand.c)
+- [server/src/hw](https://github.com/lordbasex/LordOS/tree/main/server/src/hw)
+
+## 3. O compositor
+
+### 3.1 Telas sem libdrm
+
+O `lord-server` configura os modos de tela com os ioctls DRM do kernel diretamente (`kms.c`): enumera conectores, CRTCs e planos, aloca buffers e troca a página no retraço vertical. Ele escolhe a placa que tem conectores, e não simplesmente `card0`, o que importa em placas onde o controlador de vídeo e a GPU são dispositivos separados (no Raspberry Pi 5, `vc4` e `v3d`).
+
+### 3.2 Duas formas de montar um quadro
+
+- **Caminho pela CPU.** A interface e as janelas dos apps são copiadas para um canvas, e um buffer "dumb" é apresentado com uma troca de página. Não precisa de nada além do kernel. É o padrão quando não há placa com 3D, e `LORD_GPU=0` o força (o modo de segurança do menu de boot o usa).
+- **Caminho pela GPU.** GBM, EGL e GLES2 do Mesa (`server/src/gpu/gpu.c`). A interface vira uma textura, e só a região alterada é enviada a cada quadro. As janelas dos apps não são copiadas para o canvas da interface: a interface deixa um buraco transparente onde cada janela fica, e as texturas das janelas são desenhadas por baixo, de modo que um app que só muda o próprio conteúdo não provoca repintura da interface. Os apps podem entregar buffers de GPU (`linux-dmabuf`) sem cópias, e um app em tela cheia com um buffer adequado é exibido diretamente (scanout direto). O cursor usa o plano de cursor do hardware.
+
+O caminho é escolhido na inicialização: uma placa sem 3D (simpledrm, bochs, virtio-gpu sem virgl e outras) usa a CPU sem nem carregar o Mesa; um renderizador OpenGL por software também volta para a CPU, porque compor com ele custa mais que o caminho de CPU próprio do LordOS. Se um quadro na GPU falha, a GPU é desligada e o caminho pela CPU assume.
+
+**Estado:** o caminho pela GPU foi exercitado com o renderizador por software do Mesa em máquinas virtuais. Os testes em placas AMD e Nvidia reais estão pendentes.
+
+### 3.3 Janelas e entrada
+
+- **Gerenciamento de janelas em C.** Mover e redimensionar rodam em C, com um evento por quadro e sem JavaScript, e a janela sendo movida é desenhada a partir da sua própria camada. As quatro bordas e os cantos redimensionam, com cursores próprios do LordOS.
+- **Entrada sem libinput.** Teclados, mouses e mesas digitalizadoras são lidos do evdev. Os layouts de teclado vêm do `libxkbcommon` (todos os layouts XKB, variantes e compose).
+- **Touchpad e tela sensível ao toque.** O LordOS tem seu próprio driver multitoque (`server/src/tp`): aceleração do ponteiro, toque para clicar e clique com dois dedos, rejeição da palma, rolagem cinética e natural, pinça e gestos de três dedos. Os gestos chegam tanto à interface do LordOS quanto aos apps Linux (`zwp_pointer_gestures_v1`). Ele é testado com gestos gravados no `make test`.
+
+### 3.4 Compatibilidade Wayland
+
+O compositor (`server/src/wl/wl.c`) usa apenas `libwayland-server` e código gerado a partir do XML dos protocolos. Ele oferece: `wl_compositor`, `wl_subcompositor`, `wl_shm`, `wl_output` (um por tela), `xdg_wm_base` com popups, `wl_seat` (ponteiro, teclado, toque), `wl_data_device_manager` (uma área de transferência compartilhada com o LordOS), `zxdg_decoration_manager_v1`, o protocolo de decoração do lado do servidor do KDE (para que apps GTK 3 como o Firefox recebam a moldura do tema), `zxdg_output_manager_v1`, `wp_fractional_scale_v1`, `wp_viewporter`, `zwp_linux_dmabuf_v1` v4, `wp_presentation`, `zwp_relative_pointer_manager_v1`, `zwp_pointer_constraints_v1`, `zwp_pointer_gestures_v1` e `wp_cursor_shape_manager_v1`.
+
+As janelas Linux entram no gerenciador de janelas do SDK como qualquer outra, com título, foco, maximizar, minimizar e ícone no Dock. Apps que pedem decoração do lado do servidor recebem a moldura do tema; apps que desenham a própria (GTK 4) a mantêm, e a sombra delas é recortada. Apps GTK 4 e libadwaita seguem o modo claro/escuro, a cor de destaque e a ordem dos botões por meio de uma implementação de `org.freedesktop.portal.Settings` que o próprio `lord-server` serve no barramento da sessão; o GTK 3 segue pelo keyfile do GSettings.
+
+**O Xwayland não é suportado**: o LordOS não roda apps que só falam X11. Também estão pendentes: arrastar e soltar, a seleção primária, os métodos de entrada do LordOS dentro dos apps Linux (`text-input`), ativação (`xdg-activation`), sincronização explícita e ícones de app em SVG. Nenhum protocolo de captura de tela é oferecido aos apps.
+
+### 3.5 Várias telas e HiDPI
+
+Todas as telas conectadas são controladas ao mesmo tempo, estendidas ou espelhadas, num único espaço lógico, com o arranjo lembrado pela identidade EDID e suporte a conectar e desconectar a quente. Cada tela é pintada na sua própria escala (100, 125, 150, 175 ou 200 %), então texto e vetores são rasterizados na resolução real dela. Os apps Linux recebem um `wl_output` por tela e escala fracionária. Testado com duas saídas virtuais (1280×800 e 2560×1600) nos dois caminhos; monitores reais, painéis de notebook e hubs DisplayPort não foram testados.
+
+### 3.6 Sessões e login
+
+[[diagram:sessions]]
+
+O `lord-sessiond` é o gerenciador de sessões próprio do LordOS:
+
+- **A tela de login** é um `lord-server` rodando como o usuário sem privilégios `lordos-greeter`, com um tema especial. Ela envia pedidos de login ao `lord-sessiond`; **as senhas são sempre verificadas pelo processo root** contra o `/etc/shadow`, nunca pelo JavaScript da tela de login. Tentativas que falham esperam 1, 2, 4… segundos, até 5 minutos.
+- **Uma sessão por usuário**, todas podendo existir ao mesmo tempo (troca rápida de usuário). Cada uma é um `lord-server` que começa como root e abandona os privilégios logo em seguida.
+- **Empréstimo da tela.** O `lord-sessiond` abre a placa de vídeo e os dispositivos de entrada como root e os empresta à sessão que está no monitor, por um socket Unix. Numa troca, ele os revoga: `EVIOCREVOKE` faz os descritores de entrada da sessão anterior pararem de funcionar, e `DROP_MASTER` retira o controle da tela, antes de qualquer coisa ser entregue à próxima sessão. A sessão visível continua compondo na GPU sem nunca ser root. Uma sessão fora do monitor desenha em memória, e só se alguém a estiver vendo remotamente.
+- **Bloquear a tela realmente tira a sessão do monitor**; não é uma camada desenhada por cima. Se a sessão do usuário travar, a tela de login continua funcionando.
+
+**Área de trabalho remota.** O mesmo serviço oferece o desktop a um navegador na rede local, em `https://<endereço>:5673` (5673 soletra "LORD" num teclado de telefone). Ela vem **desligada por padrão** e é ativada em Ajustes → Compartilhar. Usa TLS 1.2 ou superior com um certificado P-256 autoassinado cuja impressão digital os Ajustes mostram para comparação, uma política de segurança de conteúdo rígida, verificação de mesma origem, esperas por IP após logins com falha e um cookie de sessão `Secure`, `HttpOnly` e `SameSite=Strict`. A página de login nunca lista as contas de usuário. O processo que atende uma conexão abandona o root assim que sabe de quem é a sessão. As atualizações de tela vão em PNG quando a imagem está parada e em JPEG durante o movimento. O áudio está projetado, mas não construído. O acesso pela internet não é previsto; recomenda-se uma VPN.
+
+### Arquivos-fonte
+
+- [server/src/kms.c](https://github.com/lordbasex/LordOS/blob/main/server/src/kms.c), [server/src/gpu/gpu.c](https://github.com/lordbasex/LordOS/blob/main/server/src/gpu/gpu.c), [server/src/outputs.c](https://github.com/lordbasex/LordOS/blob/main/server/src/outputs.c)
+- [server/src/input.c](https://github.com/lordbasex/LordOS/blob/main/server/src/input.c), [server/src/tp](https://github.com/lordbasex/LordOS/tree/main/server/src/tp), [server/src/ui/grab.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/grab.c)
+- [server/src/wl/wl.c](https://github.com/lordbasex/LordOS/blob/main/server/src/wl/wl.c), [server/src/ui/portal.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/portal.c)
+- [server/src/remote/sessiond.c](https://github.com/lordbasex/LordOS/blob/main/server/src/remote/sessiond.c), [server/src/remote/monitor.c](https://github.com/lordbasex/LordOS/blob/main/server/src/remote/monitor.c), [server/src/remote/sess.c](https://github.com/lordbasex/LordOS/blob/main/server/src/remote/sess.c)
+
+## 4. O motor de interface
+
+### 4.1 Não é um navegador
+
+A interface do LordOS é escrita em JavaScript com React, mas não há motor web por baixo. WebKit ou Chromium custariam de 100 a 300 MB de RAM por processo e não seriam código do LordOS. Em vez disso, o tema e os apps usam um renderizador React (`runtime/index.js`) que cria e atualiza **nós nativos** em C: `View`, `Text`, `Image`, além de superfícies para janelas Wayland e mídia. Os estilos são um subconjunto do CSS (flexbox, cores, bordas arredondadas e por lado, sombras, desfoque, transformações, transições) aplicado por código C que o projeto controla. O modelo é parecido com o de um framework móvel que renderiza React em views nativas, só que aqui o lado "nativo" é do próprio LordOS.
+
+### 4.2 As peças
+
+- **JavaScript:** QuickJS 2025-04-26, um pequeno motor ES2023 em C, incorporado como código-fonte e embutido no `lord-server`.
+- **React:** React 19.3.1 com `react-reconciler` 0.34, empacotados com esbuild em cada tema. O tema padrão com todos os apps pesa 367 KB.
+- **Layout:** implementação própria de flexbox do LordOS (`layout.c`), com quebra de linha, bordas lógicas de início/fim e espelhamento da direita para a esquerda.
+- **Pintura:** rasterizador 2D próprio do LordOS, com retângulos arredondados com antialiasing, sombras em cache, desfoque em resolução reduzida e rastreamento de regiões alteradas: só a região que mudou é repintada. Em ARM, laços NEON opcionais aceleram cópias e máscaras, verificados como idênticos bit a bit ao código C.
+- **Texto:** os glifos são rasterizados com `stb_truetype`. O shaping é código OpenType próprio do LordOS (substituições GSUB e posicionamento GPOS, emoji colorido), com bidi Unicode completo, junção do árabe, shaping índico e o Universal Shaping Engine (409 de 409 frases de teste idênticas ao HarfBuzz em `tests/hb_compare.py`), quebra de linha CJK, separação de palavras em tailandês e fonte de reserva por escrita. HarfBuzz, FreeType, fontconfig, fribidi e ICU não são linkados pelo `lord-server`.
+- **Métodos de entrada:** coreano (hangul), japonês (kana e SKK) e chinês (pinyin), em `server/src/ime.c`, sem ibus nem fcitx.
+
+[[diagram:frame]]
+
+### 4.3 Como o JavaScript chega ao sistema
+
+O lado JavaScript chama serviços nativos pelas APIs `lord.*` implementadas em C (`server/src/ui/js_*.c`): `lord.fs` (arquivos), `lord.settings`, `lord.net`, `lord.pkg`, `lord.media`, `lord.mail`, `lord.vault`, `lord.fw`, `lord.monitor`, `lord.fan` e outras. Toda chamada valida seus argumentos em C. As regras são rígidas:
+
+- O `lord-server` roda sem root, e **nenhuma API executa comandos arbitrários**.
+- O `lord.fs` só escreve na pasta pessoal e nas montagens do próprio usuário, não tem "apagar" genérico (só mover para a Lixeira) e recusa as pastas que o sistema lê para iniciar ou instalar algo, ou que guardam decisões de segurança: `~/.local/share/applications`, `~/.config/autostart`, a pasta de apps instalados, `settings.json`, o arquivo de permissões, as regras do firewall, o arquivo de contas de e-mail e a pasta do cofre.
+- Tudo o que precisa de root passa pelo `admin.c`: uma tabela fechada de ações com argumentos validados do lado root, caminhos de programa fixos e configuração gerada pelo LordOS, nunca texto do usuário passado a um shell. As senhas vão pela entrada padrão, nunca pela linha de comando.
+- Trabalho longo nunca bloqueia um quadro: ajudantes e serviços são consultados pelo laço principal sem espera.
+
+### 4.4 Idiomas
+
+A interface vem em inglês (o padrão), espanhol e português, e novos idiomas entram como pacotes de idioma, sem mudar código. O texto passa pelo `t('namespace.key')` do SDK, com plurais e formatos regionais. A interface inteira se espelha para idiomas da direita para a esquerda, e a região (`LANG`/`LC_*`) é repassada aos apps Linux. `node tools/i18n-check.mjs` confere que toda chave existe em todos os idiomas e que nenhuma marca de terceiros aparece na interface.
+
+### Arquivos-fonte
+
+- [runtime/index.js](https://github.com/lordbasex/LordOS/blob/main/runtime/index.js), [sdk/index.js](https://github.com/lordbasex/LordOS/blob/main/sdk/index.js)
+- [server/src/ui/js.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/js.c), [server/src/ui/node.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/node.c), [server/src/ui/layout.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/layout.c), [server/src/ui/paint.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/paint.c)
+- [server/src/ui/shape.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/shape.c), [server/src/ui/otf.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/otf.c), [server/src/ui/bidi.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/bidi.c), [server/src/ime.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ime.c)
+- [server/src/ui/js_sys.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/js_sys.c), [server/src/fsops.c](https://github.com/lordbasex/LordOS/blob/main/server/src/fsops.c)
+
+## 5. Aplicativos
+
+### 5.1 Apps nativos
+
+Cerca de trinta apps nativos vêm com o LordOS, todos apps React sobre o mesmo motor e o mesmo SDK: Arquivos, Ajustes, Terminal, Loja, Editor de Texto, Notas, Calculadora, Monitor, Visualizador de PDF, Fontes, Emoji e Símbolos, Scanner, Fotos, Player, Capturas de Tela, Câmera, Gravador, Senhas, Discos, Backups, Logs, Relógio, Ajuda, E-mail, Calendário, Contatos, Lembretes, Sobre e o instalador. Alguns destaques:
+
+- **Terminal:** emulador compatível com xterm escrito pelo LordOS em C, com abas, painéis divididos, perfis, imagens embutidas e Sixel, e sessões que sobrevivem a um reinício do `lord-server`.
+- **Monitor:** CPU, memória, discos, processos, refrigeração e conexões de rede por app num mapa-múndi, com o país consultado numa base local. A thread de amostragem só existe enquanto o app está aberto.
+- **Discos:** leitor SMART próprio do LordOS, formatação e pendrives inicializáveis verificados com SHA-256.
+- **Backups:** snapshots com hard links e criptografia opcional, rodando com baixa prioridade.
+
+### 5.2 Apps `.lpk` instaláveis
+
+Os apps nativos de terceiros são empacotados como `.lpk`: um tar comprimido com gzip contendo um manifesto, o `app.js` empacotado, um ícone obrigatório e traduções e recursos opcionais. Um app não traz React nem o SDK; usa os do sistema, o que o mantém pequeno (o app de exemplo Fractal pesa 5 KB). Eles são instalados sem root em `~/.local/share/lordos/apps/<id>/`. O instalador recusa links, dispositivos, caminhos absolutos, `..`, caracteres estranhos, mais de 2.000 arquivos ou 64 MB, e substitui a versão anterior de forma atômica. Cada um roda isolado (§6.4).
+
+### 5.3 A Loja e os pacotes Debian
+
+A Loja mostra os apps do Debian por categoria, com busca, além de apps `.lpk` e arquivos `.deb` locais, e sempre mostra um plano antes de instalar ou remover. Os pacotes Debian são tratados pelo **motor de pacotes próprio do LordOS** (`server/src/pkg`): ele lê as fontes do apt, verifica as assinaturas do `InRelease` com código OpenPGP próprio (RSA e Ed25519), recusa índices expirados, reaproveitados (replay), de outra suíte ou com dados depois da assinatura, confere cada índice e cada `.deb` com os valores SHA-256 do índice assinado e resolve as dependências (planos idênticos aos do apt em 12 casos de teste). Só o último passo é do Debian: o `dpkg` desempacota e configura, e continua sendo o único que escreve no seu banco de dados, então o `apt` segue funcionando. O LordOS não tem cliente TLS próprio, então as fontes `https://` são baixadas por `http://`; a integridade depende das assinaturas e dos hashes, mas os nomes dos pacotes baixados ficam visíveis na rede.
+
+### 5.4 Apps Linux
+
+Apps Linux com um arquivo `.desktop` aparecem no lançador de apps. A abertura passa por `lord.apps.launch(id)`: a interface só pode indicar um arquivo `.desktop` instalado; o `lord-server` o relê, confere, monta o `argv` a partir da linha `Exec` conforme a especificação e o executa com `execve`, sem shell nem argumentos de quem chamou, dentro do seu próprio escopo de cgroup pertencente ao root. Chromium e Firefox vêm pré-instalados na ISO e foram verificados com a moldura do LordOS. **Os apps Linux não ficam em sandbox no LordOS**; eles ganham atribuição e o firewall por app (§6.6).
+
+### 5.5 WebAssembly
+
+O LordOS inclui seu próprio interpretador WebAssembly em C (`server/src/wasm`), exposto como o global padrão `WebAssembly`, para que um app nativo possa trazer módulos compilados de C, C++, Rust ou Zig. Ele cobre o WebAssembly 2.0 sem SIMD (o MVP mais extensão de sinal, conversões saturadas, multi-valor, memória em bloco e tipos de referência), passa em 26.290 de 26.290 asserções da suíte de testes oficial na VM e transforma todo erro num trap em vez de uma falha. No exemplo do projeto, ele rodou de 3 a 5 vezes mais rápido que o mesmo código em JavaScript.
+
+### 5.6 Instalar o LordOS
+
+- **ISO live** para PCs de 64 bits, com instalador gráfico (UEFI e BIOS).
+- **Imagem para Raspberry Pi 5**, para cartão SD ou NVMe (§7.4).
+- **Num Debian 13 já instalado**: `curl -fsSL https://lordos.org/install.sh | sh`. O script pergunta antes de mudar qualquer coisa, baixa o `SHA256SUMS` e verifica sua assinatura Ed25519 com a chave de release embutida no script, recusa continuar sem uma assinatura válida, confere o SHA-256 do `.deb`, instala com o apt e configura o sistema como a ISO. O repositório é privado até a primeira beta pública, então o caminho de download ainda não é público.
+
+### Arquivos-fonte
+
+- [apps](https://github.com/lordbasex/LordOS/tree/main/apps), [server/src/lpk.c](https://github.com/lordbasex/LordOS/blob/main/server/src/lpk.c), [tools/lpk.mjs](https://github.com/lordbasex/LordOS/blob/main/tools/lpk.mjs)
+- [server/src/pkg](https://github.com/lordbasex/LordOS/tree/main/server/src/pkg), [server/src/apps.c](https://github.com/lordbasex/LordOS/blob/main/server/src/apps.c)
+- [server/src/wasm/wasm.c](https://github.com/lordbasex/LordOS/blob/main/server/src/wasm/wasm.c), [server/src/ui/js_wasm.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/js_wasm.c)
+- [tools/install/install.sh](https://github.com/lordbasex/LordOS/blob/main/tools/install/install.sh)
+
+## 6. Segurança
+
+### 6.1 Modelo de ameaças
+
+O LordOS é projetado contra estas ameaças:
+
+- **Um app instalado malicioso ou comprometido** que quer os arquivos, as chaves, o microfone, a câmera, a área de transferência ou a rede do usuário.
+- **Documentos e mensagens maliciosos**: PDFs, arquivos compactados, fontes, imagens, vídeos e e-mails feitos para explorar um leitor.
+- **Um app Linux que quer mandar dados para fora**, ou escapar das regras definidas para ele.
+- **Um atacante na rede local** tentando usar a área de trabalho remota ou adulterar downloads.
+- **Pacotes e releases adulterados.**
+
+Fora do modelo, por enquanto: um kernel ou uma conta root comprometidos; ataques físicos; canais laterais; e apps Linux lendo os arquivos do usuário (eles rodam como o usuário, como em qualquer Debian). Os apps Linux são confinados apenas na rede.
+
+### 6.2 Privilégio mínimo
+
+- O `lord-server` roda como o usuário. Numa sessão gerenciada, ele nunca segura os dispositivos de vídeo ou de entrada por conta própria: o `lord-sessiond` os empresta e os revoga.
+- Bibliotecas que leem dados não confiáveis só são linkadas por ajudantes: FFmpeg e libva pelo `lord-media`; Poppler e libarchive pelo `lord-doc`; OpenSSL pelo `lord-maild` e pelo `lord-sessiond`; Monocypher pelo `lord-vault`.
+- Os ajudantes recebem arquivos e dispositivos como descritores abertos pelo `lord-server`; nunca abrem caminhos.
+- O compositor nunca espera por um ajudante ou por um app, então uma falha ou um travamento fica contido.
+
+### 6.3 Os processos root e suas interfaces fechadas
+
+| Processo | Aceita | Nunca faz |
+|---|---|---|
+| ajudante `admin.c` | uma tabela fixa de ações, com argumentos validados como root | ações genéricas, texto do usuário num shell |
+| `lord-sessiond` | pedidos de login da tela de login; JSON curto de sessão (≤ 4 KB) | deixar a tela de login verificar senhas; ler pixels como root |
+| seu processo filho de posicionamento em cgroups | `enter <scope> <limits>` só para o próprio processo que pede, vindo da folha `server` de uma sessão e rodando um binário da pasta do `lord-server` | posicionar processos arbitrários; devolver a árvore ao usuário |
+| `lord-netd` | ações `net-*` vindas apenas de pares root | ações que não são de rede; rodar qualquer coisa vinda de uma sessão |
+| `lord-netperm` | `RELOAD` sem dados | rodar programas; receber argumentos; abrir sockets de internet |
+| `lord-fand` | `STATUS` para qualquer um; `PROFILE`, `CURVE`, `FORCE` para administradores | indicar caminhos ou dispositivos; rodar programas; usar a rede |
+
+### 6.4 O sandbox de apps
+
+Cada app `.lpk`, e o app Senhas, roda como `lord-server --app <id>`: o mesmo binário em "modo app", iniciado pelo `lord-server` com um id de pacote validado como único argumento. O processo se conecta ao compositor como cliente Wayland e abre o socket do broker, depois aplica o sandbox e só então carrega o código do app (`server/src/sec/sandbox.c`):
+
+- **Landlock** (ABI até 6): acesso somente leitura ao pacote, ao runtime compartilhado de apps, às fontes e às bibliotecas; leitura e escrita só em `~/.local/share/lordos/appdata/<id>`; escopo restrito para sockets Unix abstratos e sinais.
+- **seccomp-bpf**: uma lista de chamadas de sistema permitidas, em todas as threads (TSYNC), sem `ptrace`, `mount`, `kexec`, `bpf`, `perf_event_open`, `keyctl`, carregamento de módulos ou `execve`. Novos sockets Unix e `socketpair` são recusados, porque o Landlock até a ABI 6 não filtra `connect` para sockets Unix com nome; isso mantém o app longe do barramento da sessão, do serviço de impressão e do socket Wayland.
+- **Sem privilégios**: `no_new_privs`, um conjunto de capacidades vazio e o bounding set descartado.
+- **cgroup v2**: `app-lordos-lpk-<id>.scope`, criado pelo root, com `memory.high` de 192 MB, `memory.max` de 512 MB e um núcleo de CPU.
+- **Rede**: sem a permissão `network` (declarada **e** permitida), o seccomp recusa sockets de internet e o Landlock recusa connect e bind TCP. Namespaces de rede não são usados, porque criar um exige privilégios que o `lord-server` não tem.
+
+Se faltar um recurso do kernel, o app inicia mesmo assim e o log diz qual parte está faltando. O app de teste propositalmente malicioso (`tests/lpk-evil`) falha em tudo o que tenta; o `build/sandbox-test` passa em 14 de 14 verificações para apps e 14 de 14 com rede. Medido numa VM: cerca de 13,7 MB de RSS por app isolado, inicialização mediana de 106 ms e 0,89 ms para aplicar o sandbox.
+
+### 6.5 O broker, as permissões e o diálogo de arquivos
+
+[[diagram:permission]]
+
+O app isolado só fala com o `lord-server` por um socket `SOCK_SEQPACKET`. Cada pedido é conferido em C: acesso a arquivos só dentro da pasta de dados do próprio app; leitura da área de transferência só com a permissão `clipboard`; pedidos de permissão respondidos pela decisão salva ou, se não houver, por um **aviso desenhado pelo sistema** (*Permitir / Não permitir*); câmera e microfone só através do `lord-server`.
+
+- **As decisões** ficam salvas por usuário em `~/.config/lordos/permisos.json`, fora do alcance do app. A consulta é O(1).
+- **O diálogo de arquivos é o powerbox próprio do LordOS** (`sdk/powerbox.jsx`), não o `xdg-desktop-portal`: o `lord-server` o desenha, abre o arquivo escolhido e passa só aquele descritor. A única interface de portal de desktop que o LordOS implementa é `org.freedesktop.portal.Settings`, para o tema do GTK.
+- **Microfone:** o `lord-server` é dono do fluxo do PipeWire e dá ao app um anel compartilhado somente leitura.
+- **Câmera:** o `lord-server` abre o dispositivo e o entrega só ao `lord-media`; o app recebe uma visão somente leitura dos quadros decodificados e precisa confirmar cada um, e o `lord-server` valida cada confirmação.
+- **Revogação:** negar a câmera ou o microfone nos Ajustes os interrompe na hora (o `lord-media` do app é encerrado; o fluxo do PipeWire é fechado). A permissão `network` é decidida na inicialização.
+- **Chaveiro:** os pedidos ao chaveiro de um app isolado levam um dono que o `lord-server` define a partir do id verificado do app.
+
+**Limites.** Não há "permitir uma vez". Algumas permissões declaráveis (Bluetooth, abrir apps, notificações) ainda não têm chamada no broker, então os apps isolados simplesmente não podem usar esses recursos; escutar numa porta depende da permissão de rede. Um app Linux rodando como o usuário poderia editar o arquivo de permissões.
+
+### 6.6 O firewall por app e o Monitor
+
+[[diagram:firewall]]
+
+O `lord-netperm` aplica regras de rede por app no kernel. Os apps Linux abertos pelo lançador de apps rodam em `app-lordos-<id>.scope`, os apps `.lpk` em `app-lordos-lpk-<id>.scope`, e o resto da sessão conta como `lordos`. Todos os escopos pertencem ao root. O serviço carrega sete programas eBPF de cgroup (`connect4/6`, `sendmsg4/6`, `bind4/6`, `sock_create`) no cgroup do `lordos.service`, descobre o app de cada processo pelo seu ancestral de cgroup e devolve permitir ou negar (`EPERM`). Os programas são compilados dentro do binário e carregados com o carregador próprio do LordOS pela chamada de sistema `bpf()`; libbpf e bcc não são usados.
+
+- **As regras** aceitam domínios exatos, curingas, redes IPv4/IPv6, `lan`, `internet`, portas, protocolos e direção. As restrições (sem internet, sem LAN, sem rede, sem conexões de entrada) vêm primeiro; depois vence a regra mais específica, com negar ganhando de permitir em especificidade igual; depois os apps confiáveis; depois o modo (silencioso, o padrão, ou desligado). O `npcompile.c` pré-calcula isso em mapas de hash e de maior prefixo correspondente. Um teste roda o código de decisão do kernel contra o decisor de referência em 480.000 conexões aleatórias: 0 diferenças.
+- **Os nomes de domínio** vêm só do resolvedor do sistema: a interface de monitoramento do systemd-resolved ou, sem ele, respostas da porta 53 dos servidores configurados, lidas por um socket de pacotes que só recebe. Respostas que um app recebeu nos próprios sockets nunca são levadas em conta.
+- **Fugas.** A árvore de cgroups pertence ao root, então um app não consegue se mover. Um processo que pede ao gerenciador systemd do usuário uma nova unidade (`systemd-run --user`) cai sob `user@<uid>.service`; o `lord-netperm` anexa os mesmos programas ali e submete esses processos à união mais estrita das restrições dos apps restritos daquele usuário em execução. Testado: todas as tentativas de fuga negadas, outros usuários não afetados.
+- **Custo**: cerca de 0,5 µs por connect UDP, TCP dentro do ruído, nenhuma mudança na vazão, já que nada roda por pacote.
+- **O Monitor** mostra as conexões de cada app (a partir de `sock_diag`), os bytes, os destinos por país a partir de uma base local e um botão de Regra por app. Nenhum endereço sai da máquina para consultas: sem DNS reverso, sem geolocalização online.
+
+**Limites.** O modo "perguntar" está projetado, mas hoje se comporta como o silencioso. Ainda não há interface para regras por domínio nem botões por destino (o motor e a API já os suportam). O ICMP só é bloqueado por "sem rede"; conexões a uma porta já aberta não são conferidas. Os Ajustes também oferecem restrições que não são de rede (câmera, microfone, tela, USB, Bluetooth, arquivos, notificações): elas ficam salvas, mas **nenhum componente as aplica ainda**.
+
+### 6.7 Ajudantes que processam dados não confiáveis
+
+[[diagram:helpers]]
+
+O `lord-doc` (PDF, arquivos compactados, fontes, imagens do scanner), o `lord-media` (vídeo, áudio, fotos, câmera), o `lord-maild` (e-mail, calendários, contatos) e o `lord-vault` (segredos) compartilham um único sandbox reforçado, `sandbox_apply_helper()`:
+
+- sem `socket`, `socketpair`, `connect`, `bind`, `listen`, `accept`; sem `execve`; `clone` só para threads; seccomp em todas as threads, e se o seccomp não puder ser aplicado o ajudante encerra;
+- arquivos só por descritores passados pelo `lord-server`; ioctls só por classe (DRM, V4L2, DMA-BUF), quando necessário;
+- resultados devolvidos em memória compartilhada selada, validados pelo `lord-server`.
+
+O `lord-media` nem sequer recebe o socket do PipeWire; o áudio passa por um anel compartilhado cujo fluxo pertence ao `lord-server`. O `lord-maild` não consegue criar sockets: ele pede ao `lord-server`, que só se conecta aos servidores do arquivo de contas (e, depois que o usuário pede para carregar imagens, só a endereços públicos nas portas 80/443 por dez minutos) e entrega o socket já conectado. O `build/sandbox-test helper` passa em 17 de 17 verificações.
+
+### 6.8 Assinatura de pacotes e níveis de confiança
+
+Os pacotes `.lpk` trazem um manifesto com o SHA-256 de cada arquivo e uma assinatura Ed25519 sobre ele. SHA-256 e Ed25519 são código próprio do LordOS (o Ed25519 segue a aritmética do TweetNaCl), testados com os vetores do NIST e da RFC 8032 (55 de 55). A verificação acontece em C na instalação e no carregamento. A Loja mostra o nível de confiança: **LordOS** (chave oficial, compilada dentro do binário para que nenhum arquivo possa acrescentar outra), **Autor verificado** (listado no catálogo assinado), **Assinado por <nome>** ou **Não assinado**, com um aviso. As atualizações precisam ser assinadas com a mesma chave. Um catálogo assinado traz uma lista de revogação. Se você editar um app instalado, o LordOS o marca como "Modificado por você", pode restaurar o original ou pode compartilhar sua versão assinada com sua própria chave, dando crédito ao original.
+
+**Estado:** hoje os pacotes oficiais são assinados com uma chave de desenvolvimento; a chave definitiva a substitui no lançamento público. Um repositório de apps do LordOS assinado para a Loja ainda não foi construído.
+
+### 6.9 Assinatura dos releases
+
+Cada arquivo de release (o `.deb`, a ISO e a imagem do Raspberry Pi) aparece com seu SHA-256 no `SHA256SUMS`, e o `SHA256SUMS` é assinado com a chave de release do LordOS (Ed25519). A chave pública é `tools/release/lordos-release.pub.pem`, também embutida no instalador para Debian. Sua impressão digital (SHA-256 da chave pública em DER) é:
+
+`c7155b8e6bbbb180f907381994d06af76d333016cd6f3facf67cadd053ea108e`
+
+A chave privada fica só na máquina do mantenedor, nunca no repositório nem numa máquina de build. A §11 mostra como conferir um download.
+
+### 6.10 O cofre
+
+O `lord-vault` guarda as senhas e o chaveiro da sessão em arquivos `.lvault`: uma chave de cofre aleatória de 32 bytes, envolvida uma vez por método de desbloqueio (senha com Argon2id, com custo calibrado por máquina; FIDO2 `hmac-secret` com o cliente CTAP2 próprio do LordOS; arquivo-chave; senha mais arquivo-chave; chave de recuperação); conteúdo selado com XChaCha20-Poly1305, tendo o cabeçalho inteiro como dados associados; anexos selados separadamente; gravações atômicas com backup. Todo byte invertido e todo truncamento são detectados (1.165 de 1.165 no teste). Os segredos ficam numa área de memória travada com `mlock`, excluída dos core dumps e apagada ao ser liberada, num processo que não pode ser despejado (dump). A janela de Senhas roda no seu próprio processo em sandbox, então os valores revelados nunca entram no JavaScript do desktop. O chaveiro abre no login com a senha que o `lord-sessiond` verificou e atende os apps Linux pela implementação própria do Secret Service do LordOS. Chaves de segurança de hardware reais ainda não foram testadas.
+
+### 6.11 Janelas protegidas
+
+Uma janela marcada como protegida (como a de Senhas) é pintada de preto em todo caminho que copia pixels para fora: capturas de tela, gravações, miniaturas, a área de trabalho remota e os menus e a tela cheia do Wayland. O monitor real a mostra normalmente. Os apps Linux nem têm protocolo de captura de tela, para começo de conversa.
+
+### Arquivos-fonte
+
+- [server/src/sec/sandbox.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/sandbox.c), [server/src/sec/brokersrv.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/brokersrv.c), [server/src/sec/perms.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/perms.c), [server/src/sec/cgroup.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/cgroup.c)
+- [server/src/netperm/np.bpf.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/np.bpf.c), [server/src/netperm/netperm.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/netperm.c), [server/src/fw/rules.c](https://github.com/lordbasex/LordOS/blob/main/server/src/fw/rules.c)
+- [server/src/sec/sign.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/sign.c), [server/src/pkg/crypto.c](https://github.com/lordbasex/LordOS/blob/main/server/src/pkg/crypto.c), [tools/release/sign-release.sh](https://github.com/lordbasex/LordOS/blob/main/tools/release/sign-release.sh)
+- [server/src/vault/vault.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/vault.c), [server/src/vault/vfile.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/vfile.c)
+- [server/src/media/capture.c](https://github.com/lordbasex/LordOS/blob/main/server/src/media/capture.c)
+
+## 7. Desempenho
+
+Todos os números abaixo foram medidos pelo projeto e estão documentados nos arquivos citados. A maioria vem de máquinas virtuais; as medições em hardware real estão indicadas como tal.
+
+### 7.1 Memória e repouso
+
+| Medição | Valor | Onde |
+|---|---|---|
+| Sistema inteiro, ISO live, em repouso depois de um minuto (4 GB, 4 núcleos) | 465 MB em uso, CPU 99 % ociosa | VM 117, `docs/ISO.md` |
+| Sistema inteiro, instalado a partir da ISO, em repouso | 487 MB em uso, CPU 99 % ociosa | VM 120, `docs/ISO.md` |
+| Boot, ISO live com UEFI | 16,3 s (4,9 s de kernel + 11,4 s de espaço de usuário) | VM 117, `docs/ISO.md` |
+| `lord-server` sem placa com 3D (Mesa não carregado) | cerca de 32 MB de RSS | `docs/GPU.md` |
+| Uma sessão de usuário (`lord-server`), testes de área de trabalho remota | cerca de 50 MB; tela de login 41 MB | VM 118, `docs/REMOTE.md` |
+| Um app `.lpk` isolado | 13,7 MB de RSS | VM 122, `docs/PRIVACY.md` |
+
+### 7.2 Desenho
+
+- Arrastar uma janela numa tela de 1280×800 pelo caminho da CPU: cerca de 6,7–6,9 ms de trabalho por quadro, por volta de 120 quadros por segundo (VM 118, `docs/DISPLAYS.md`).
+- A mesma janela numa tela de 2560×1600 a 150 %: cerca de 5,1 ms por quadro.
+- Vídeo: pintar direto do quadro decodificado quando só um vídeo opaco mudou levou o `lord-server` de 42 % para 13 % de um núcleo com um vídeo 1080p em janela, e de 92 % para 15 % em tela cheia (`docs/ROADMAP.md`, mídia).
+- O Monitor fechado não custa nada: a thread de amostragem não existe até ele ser aberto (`docs/MONITOR.md`).
+
+### 7.3 GPU
+
+Nas VMs só havia um renderizador por software disponível. Com ele, o caminho pela CPU sai mais barato que a composição "na GPU", e é por isso que o LordOS usa o caminho pela CPU quando o único renderizador é por software. O benefício real do caminho pela GPU (composição e apresentação quase de graça, tela cheia sem cópias) é esperado em placas reais, mas **hardware AMD e Nvidia real ainda não foi medido**.
+
+### 7.4 O Raspberry Pi 5
+
+O Raspberry Pi 5 é a única placa suportada. Resultados numa placa real (16 GB, cartão SD, sem monitor), de `docs/RASPBERRY.md`:
+
+| Medição | Valor |
+|---|---|
+| Compilar todos os binários do LordOS na placa | 1 min 02 s, 0 avisos |
+| `make -C server test` | 23 aprovados, 0 falhas, 0 pulados |
+| Cópia e máscara com NEON vs. C puro | 9,90 → 4,33 ms e 11,09 → 5,49 ms por tela (2,0–2,3×), idênticos bit a bit |
+| Em repouso na tela de login, sem monitor | `lord-server` 36 MB de RSS, 0,6 % de CPU; sistema com 450 MB de 16 GB; 38–43 °C, sem limitação térmica |
+| Gerar a imagem SD na placa | 8 min 18 s; 503 MB comprimida |
+| Compilar o kernel do LordOS na placa | cerca de 50 min por variante |
+
+**O kernel do LordOS.** O kernel do próprio Raspberry Pi não inclui o Landlock. Sem ele, o teste hostil do ajudante de documentos falha em 5 das suas 25 verificações de sistema de arquivos e o teste do sandbox não consegue rodar. O LordOS compila o kernel do Raspberry Pi a partir do código-fonte e da configuração padrão dele, mudando só três opções (Landlock ligado, a lista de LSMs, o sufixo de versão), e o fixa para que um kernel mais novo do repositório não o substitua. A imagem também ativa o cgroup de memória, que o Raspberry Pi desliga no boot.
+
+**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`).
+
+**Ainda não verificado na placa:** tudo o que envolve um monitor conectado (configuração de modo, composição na GPU na tela, taxa de quadros), a sessão de desktop e o boot da imagem gerada.
+
+### 7.5 PCs modernos
+
+Ainda não há medições em PCs reais no repositório. A ISO é testada em máquinas virtuais (UEFI e BIOS); está planejado testá-la numa máquina AMD real a partir do pendrive live.
+
+### Arquivos-fonte
+
+- [docs/ISO.md](https://github.com/lordbasex/LordOS/blob/main/docs/ISO.md), [docs/RASPBERRY.md](https://github.com/lordbasex/LordOS/blob/main/docs/RASPBERRY.md), [docs/FANS.md](https://github.com/lordbasex/LordOS/blob/main/docs/FANS.md), [docs/DISPLAYS.md](https://github.com/lordbasex/LordOS/blob/main/docs/DISPLAYS.md)
+- [tools/rpi/build-kernel.sh](https://github.com/lordbasex/LordOS/blob/main/tools/rpi/build-kernel.sh), [tools/rpi/build-img.sh](https://github.com/lordbasex/LordOS/blob/main/tools/rpi/build-img.sh)
+- [server/src/canvas.c](https://github.com/lordbasex/LordOS/blob/main/server/src/canvas.c)
+
+## 8. Experiência visual
+
+- **Um guia de design.** Os apps seguem um guia comum (`docs/DESIGN.md`): uma grade de espaçamento de 8 px, uma escala tipográfica enxuta, alturas de controle consistentes e uma única ação na cor de destaque por tela. Os tokens são exportados pelo SDK (`spacing`, `typeScale`, `controlSize`), e cada app passou por rodadas de acabamento documentadas, com antes e depois, nos modos claro e escuro, da direita para a esquerda e em janelas pequenas.
+- **Temas.** Um tema é um desktop completo escrito em React: barra de menus, Dock, lançador de apps, Central de Controle e moldura das janelas, além dos seus tokens. O LordOS traz um tema padrão com barra de menus e Dock, e um tema Clássico com barra de tarefas e menu iniciar. Os temas trocam ao vivo; as configurações persistem.
+- **Claro e escuro, cores de destaque.** Os dois modos e a cor de destaque se aplicam ao vivo aos apps nativos, aos apps isolados e, pelo portal e pelo GSettings, aos apps GTK.
+- **Direita para a esquerda.** A interface inteira se espelha para árabe, hebraico e escritas parecidas, incluindo os apps isolados, que seguem o idioma da sessão ao vivo.
+- **Lumo.** O mascote do LordOS é o Lumo, uma pequena raposa celestial, usado em telas de boas-vindas, estados vazios e material de marca, com um conjunto fixo de poses definido no guia da marca.
+- **Acessibilidade hoje:** uma opção de "reduzir movimento" que desliga as animações decorativas, atalhos de teclado em toda parte e telas escaláveis até 200 %. Um leitor de tela, zoom e alto contraste estão no roadmap e **ainda não foram construídos**.
+
+### Arquivos-fonte
+
+- [docs/DESIGN.md](https://github.com/lordbasex/LordOS/blob/main/docs/DESIGN.md), [docs/LORDOS-BRAND.md](https://github.com/lordbasex/LordOS/blob/main/docs/LORDOS-BRAND.md)
+- [themes](https://github.com/lordbasex/LordOS/tree/main/themes), [sdk/controls.jsx](https://github.com/lordbasex/LordOS/blob/main/sdk/controls.jsx), [sdk/i18n.js](https://github.com/lordbasex/LordOS/blob/main/sdk/i18n.js)
+
+## 9. Extensibilidade
+
+- **O SDK** (`@lordos/sdk`) é a única coisa que os apps importam: janelas, configurações, tokens do tema, controles, arquivos, mídia, notificações, chaveiro, impressão e mais. Os apps não importam nada dos temas, então qualquer app funciona em qualquer tema.
+- **Escrever um app** é uma pasta com `manifest.json` e `index.jsx`. `node tools/lpk.mjs <folder>` empacota sem React nem o SDK, acrescenta o ícone e as traduções e assina se houver uma chave; `keygen`, `sign`, `verify` e `catalog` cobrem o resto. Os apps podem incluir módulos WebAssembly e desenhar pixels diretamente com `<Image pixels>`.
+- **Os temas** seguem um contrato fixo (`Desktop`, `MenuBar`, `Dock`, `Launcher`, `ControlCenter`, `WindowFrame`, tokens), documentado em `themes/README.md`, com o tema Clássico como modelo.
+- **A interoperabilidade com Linux** se dá por padrões: Wayland, o portal de configurações, o Secret Service, o serviço de notificações, os apps padrão do `mimeapps.list` e os arquivos `.desktop`.
+- **Automação:** hoje não há API de scripts ou automação além do SDK. Integrações com assistentes de IA (por exemplo, pelo Model Context Protocol) **não existem no LordOS**; são apenas uma possível direção futura e teriam de respeitar a mesma regra de que o JavaScript não executa comandos.
+
+### Arquivos-fonte
+
+- [sdk](https://github.com/lordbasex/LordOS/tree/main/sdk), [apps/README.md](https://github.com/lordbasex/LordOS/blob/main/apps/README.md), [themes/README.md](https://github.com/lordbasex/LordOS/blob/main/themes/README.md)
+- [docs/NATIVE-APPS.md](https://github.com/lordbasex/LordOS/blob/main/docs/NATIVE-APPS.md), [docs/WASM.md](https://github.com/lordbasex/LordOS/blob/main/docs/WASM.md), [examples/apps/fractal](https://github.com/lordbasex/LordOS/tree/main/examples/apps/fractal)
+
+## 10. Roadmap e limitações
+
+### 10.1 Onde as coisas estão
+
+Os marcos M1 a M9 estão completos na 0.7.0 Beta: o servidor gráfico, o motor de interface, o SDK e os temas, o terminal, idiomas e escritas complexas, compatibilidade com apps Linux, pacotes e serviços do sistema, sessões, isolamento e o firewall, e os conjuntos de apps do M9 (documentos e impressão, mídia, apps de sistema, senhas, configurações de hardware, e-mail e calendário). A ISO final foi gerada e testada em máquinas virtuais em 18 de outubro de 2026.
+
+### 10.2 Limitações conhecidas
+
+- Hardware real: GPUs AMD e Nvidia, monitores reais, notebooks (bateria, brilho da tela, tampa), controladoras Bluetooth, impressoras e scanners, chaves FIDO2 e provedores de e-mail reais não foram testados.
+- O Raspberry Pi 5 não foi testado com monitor, e a imagem gerada ainda não foi inicializada.
+- Os apps Linux não ficam em sandbox; não há Xwayland.
+- Firewall: sem modo "perguntar", sem interface para regras por domínio, restrições que não são de rede não aplicadas.
+- Permissões: sem "permitir uma vez"; o uso de câmera e microfone pelos apps Linux não é mostrado.
+- O Secure Boot precisa estar desligado; a assinatura com um shim está pendente.
+- Os downloads de pacotes usam HTTP (assinados e com hash).
+- A área de trabalho remota não tem áudio.
+- Acessibilidade (leitor de tela, zoom, alto contraste) não foi construída.
+
+### 10.3 Próximos passos
+
+Antes do lançamento final: a ISO final com tudo e uma imagem do Raspberry Pi 5 testada na placa real. Depois dele, como planejado em `docs/ROADMAP.md`: um app de virtualização para desktop construído sobre KVM e QEMU; um contêiner Android com LineageOS e apps da Loja do LordOS; o modo "perguntar" do firewall; acessibilidade; e um vídeo de demonstração completo.
+
+### Arquivos-fonte
+
+- [docs/ROADMAP.md](https://github.com/lordbasex/LordOS/blob/main/docs/ROADMAP.md), [CHANGELOG.md](https://github.com/lordbasex/LordOS/blob/main/CHANGELOG.md)
+
+## 11. Como verificar o projeto você mesmo
+
+### 11.1 Compile
+
+Numa máquina de desenvolvimento com Node.js, empacote os temas, o SDK e os apps:
+
+```
+npm install && npm run build
+```
+
+No Debian 13, compile os binários e rode os testes:
+
+```
+sudo apt-get install -y --no-install-recommends build-essential
+make -C server -j4
+make -C server test # every self-contained suite
+make -C server test-full # adds the helpers, the sandbox and the HarfBuzz comparison
+```
+
+O `make test` falha se alguma suíte falhar; uma suíte cuja ferramenta ou cujos dados não estão instalados informa "skipped" em vez de passar em silêncio. Os testes do sandbox precisam de um kernel com Landlock. A ISO e a imagem do Raspberry Pi são geradas como descrito em `docs/ISO.md` e `docs/RASPBERRY.md`.
+
+### 11.2 O que os testes cobrem
+
+- **Terminal e texto:** o emulador VT, o shaping OpenType comparado ao HarfBuzz, o bidi Unicode comparado ao arquivo de teste oficial, os métodos de entrada, a separação de palavras em tailandês comparada à libthai.
+- **Segurança:** o sandbox (app, rede, ajudante), a assinatura (vetores do NIST e da RFC 8032), o estado dos pacotes, as regras de caminhos de extração contra arquivos compactados maliciosos, as proteções do `lord.fs`, as regras do firewall (com 20.000 mutações de JSON e 30.000 operações aleatórias contra uma referência linear), o leitor de DNS (200.000 pacotes aleatórios), o compilador dos mapas do kernel (480.000 conexões) e o teste de integração com o kernel (18 de 18 numa VM).
+- **Leitores:** e-mail, MIME, sanitizador de HTML, iCalendar, vCard e XML (30.953 verificações com fuzzing por mutação), o formato do cofre, os importadores, QR, CBOR, serialização D-Bus, o leitor da base de países, journal, TZif e IPP.
+- **Motor e hardware:** layout e pintura, NEON vs. C, o driver de touchpad com gestos gravados, as ventoinhas em árvores sysfs simuladas, o arranjo de telas, o som e a suíte de especificação do WebAssembly.
+
+Na geração da ISO final, o `make -C server test` informou 23 aprovados, 0 falhas, 1 pulado (dados de bidi não instalados).
+
+### 11.3 Confira um release
+
+Baixe o `SHA256SUMS`, o `SHA256SUMS.sig`, os arquivos do release e a chave pública (`tools/release/lordos-release.pub.pem`). Confira que a impressão digital da chave é `c7155b8e6bbbb180f907381994d06af76d333016cd6f3facf67cadd053ea108e` e então, com o OpenSSL 3:
+
+```
+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
+```
+
+### 11.4 Confira um sistema em execução
+
+- `systemctl status lord-netperm lord-fand lordos` mostra os serviços; o teste da ISO confirmou sete programas BPF anexados.
+- `cat /proc/<pid>/status | grep -E 'Seccomp|NoNewPrivs'` num processo `lord-server --app` mostra o sandbox.
+- `systemd-cgls` mostra a árvore `lordos-session-<uid>` pertencente ao root, com um escopo por app.
+- Área de trabalho remota: `ss -ltn` não mostra nada na porta 5673 até você ativá-la em Ajustes → Compartilhar.
+
+## 12. Licença e créditos
+
+O código do LordOS é distribuído sob a **licença MIT**. Os componentes de terceiros mantêm suas próprias licenças, listadas em `THIRD_PARTY.md`: QuickJS e stb (incorporados como código-fonte), Monocypher (CC0/BSD-2), a lista de palavras da EFF (CC BY 3.0 US), a lista de senhas comuns (MIT), os dados de países do DB-IP Lite (CC BY 4.0), Natural Earth (domínio público) e as fontes Inter, JetBrains Mono e Plus Jakarta Sans (OFL).
+
+O LordOS é criado pelo grupo **IPERFEX**: **Pablo Miranda** e **Federico Pereira**.
+
+## 13. Glossário
+
+- **Broker:** o único socket pelo qual um app isolado pede ao `lord-server` qualquer coisa que toque nas coisas do usuário; cada pedido é conferido em C.
+- **cgroup (v2):** um mecanismo do kernel que agrupa processos para contabilizar e limitar recursos. O LordOS dá a cada app seu próprio grupo, um "escopo", e o usa para identificar o app no firewall.
+- **Compositor:** o programa que combina as janelas de todos os apps na imagem final da tela.
+- **DRM/KMS:** as interfaces do kernel para dispositivos gráficos e para configurar modos de tela.
+- **eBPF:** pequenos programas verificados que rodam dentro do kernel; o LordOS os anexa aos cgroups para decidir sobre conexões de rede.
+- **evdev:** a interface do kernel para dispositivos de entrada.
+- **Ajudante:** um pequeno processo do LordOS que lida com dados não confiáveis ou segredos num sandbox mais rígido (`lord-doc`, `lord-media`, `lord-maild`, `lord-vault`).
+- **Landlock:** um recurso do kernel que permite a um processo sem privilégios restringir quais arquivos e portas de rede ele, e seus filhos, podem usar.
+- **`.lpk`:** o formato de pacote do LordOS para apps nativos instaláveis.
+- **`.lvault`:** o formato de arquivo do cofre criptografado do LordOS.
+- **Powerbox:** um diálogo de arquivos desenhado pelo sistema que entrega ao app só o arquivo escolhido pelo usuário.
+- **QuickJS:** um pequeno motor JavaScript escrito em C.
+- **Escopo:** um cgroup para um app, como `app-lordos-lpk-<id>.scope`.
+- **seccomp-bpf:** um filtro do kernel que restringe quais chamadas de sistema um processo pode fazer.
+- **Secret Service:** o padrão D-Bus do freedesktop que os apps Linux usam para guardar segredos.
+- **Wayland:** o protocolo entre os apps gráficos e o compositor.
+
+## 14. Para ler mais
+
+| Capítulo | Documentos em `docs/` |
+|---|---|
+| 1. Visão | ARCHITECTURE.md, LORDOS-BRAND.md |
+| 2. Arquitetura | ARCHITECTURE.md, NETWORK.md, FANS.md, SETTINGS.md, SYSTEM.md |
+| 3. Compositor | GPU.md, DISPLAYS.md, WINDOWS.md, TRACKPAD.md, WAYLAND.md, SESSIONS.md, REMOTE.md |
+| 4. Motor de interface | ARCHITECTURE.md, LANGUAGES.md, TERMINAL.md |
+| 5. Aplicativos | NATIVE-APPS.md, PACKAGES.md, WASM.md, FILES.md, MEDIA.md, DOCUMENTS.md, MAIL.md, ISO.md, INSTALL-DEBIAN.md |
+| 6. Segurança | PRIVACY.md, FIREWALL.md, MONITOR.md, SIGNING.md, PASSWORDS.md, MEDIA.md, REMOTE.md |
+| 7. Desempenho | ISO.md, RASPBERRY.md, FANS.md, DISPLAYS.md, GPU.md |
+| 8. Experiência visual | DESIGN.md, LORDOS-BRAND.md, LANGUAGES.md, DOCK.md |
+| 9. Extensibilidade | NATIVE-APPS.md, WASM.md, e `apps/README.md`, `themes/README.md` |
+| 10. Roadmap | ROADMAP.md e `CHANGELOG.md` |
diff --git a/web/content/well-known/security.txt b/web/content/well-known/security.txt
new file mode 100644
index 0000000..ddff7a1
--- /dev/null
+++ b/web/content/well-known/security.txt
@@ -0,0 +1,7 @@
+# Security contact for LordOS and lordos.org (RFC 9116).
+# Please report vulnerabilities privately; see the policy below.
+Contact: mailto:[[SECURITY_EMAIL]]
+Expires: 2027-10-18T00:00:00.000Z
+Preferred-Languages: en, es, pt
+Canonical: https://lordos.org/.well-known/security.txt
+Policy: https://lordos.org/legal/security/