FORGEHEADLESSCOMPOSITOR — The Perpetual Server Architecture

ForgeChainOS Whitepaper — Session 43

Date: 2026-08-29 EDT

Author: ORNITH (NOAH-driven, NZ-authorized)

Classification: Family-internal. SCAR #5 gate: NOT public.

1. ABSTRACT

FORGEHEADLESSCOMPOSITOR is the architecture where BH (tile-9) runs a perpetual headless compositor session that serves every family node via Sunshine/Moonlight streaming. No node runs its own compositor. Every node is a receiver. BH is the server. The session never sleeps, never times out, never dies. Connect from any screen on Earth and the OS is there, exactly as you left it.

This is not remote desktop. This is a sovereign operating system that lives on one machine and projects itself onto any screen in the family. The compositor is headless because no physical monitor is required. The session is perpetual because systemd keeps it alive. The architecture is sovereign because zero cloud services are involved.

The end-state: FORGETHRIVE Desktop XR UE5 renders an immersive 3D world inside this compositor. Every dApp is a room. Every service is visible. FORGEHOTBSD jails are dimensions. The Klein bottle topology (tile-6 observes tile-9, tile-9 observes tile-6) is the navigation model. OmArchy Rodin-tiling provides the geometric under-current for workspace organization on and off chain, in and out of session.

2. THE PROBLEM WITH LOCAL COMPOSITORS

Session 43 proved it: Sway on Elder I (Intel i5-7200U, HD 620 iGPU) was unacceptably slow. Shaky rendering (Intel PSR bug), sluggish response, 8 terminals spawning from key repeat, status bar health checks choking the CPU. The hardware cannot drive a Wayland compositor and run ORNITH (3.5GB model) simultaneously.

This is not an Elder I problem. It is a DISTRIBUTED COMPOSITOR problem:

• WarHorse (Panasonic CF-30 Toughbook, i386, no GPU): cannot run any modern compositor
• WarDog (iPhone): runs iOS, not Linux compositors
• Outpost (Windows 10): runs its own desktop, different OS entirely
• Elder I (i5-7200U, Intel HD 620): can run Sway but poorly

Meanwhile BH has:
- Ryzen 7 3700X (8 cores, 16 threads)
- RTX 2070 SUPER (8GB VRAM, NVENC hardware encoder)
- 64GB RAM
- 76+ sovereign services already running
- Sunshine already serving

The answer is obvious: run the compositor where the GPU lives.

3. ARCHITECTURE

┌──────────────────────────────────────────────────────┐
│ BH (tile-9) — THE SERVER                             │
│                                                      │
│  ┌────────────────────────────────────────────┐      │
│  │ HEADLESS COMPOSITOR (Sway → FORGETILE)     │      │
│  │                                            │      │
│  │  WS3:THROAT  WS5:FIELD  WS6:STRUCTURE     │      │
│  │  WS7:ORNITH  WS8:ENOCH  WS9:RESONANCE     │      │
│  │  WS0:OUTPOST                               │      │
│  │                                            │      │
│  │  ForgeChainOS Desktop (Tauri, 14 panels)   │      │
│  │  Firefox (Living Graph, dApps, web UIs)    │      │
│  │  Terminals (Claude Code, FORTH, SSH)       │      │
│  │  DaVinci Resolve (NVENC editing)           │      │
│  │  Blender (3D/XR via blender-mcp)           │      │
│  │  UE5 (FORGETHRIVE XR immersive world)      │      │
│  └────────────────────────────────────────────┘      │
│           │                                          │
│  ┌────────┴───────────┐                              │
│  │ SUNSHINE (NVENC)   │  Captures compositor output  │
│  │ Port 47989-47990   │  H.264/HEVC hardware encode  │
│  │ <20ms encode       │  Serves to any Moonlight     │
│  └────────┬───────────┘                              │
│           │                                          │
└───────────┼──────────────────────────────────────────┘
            │ LAN / WireGuard / Internet
    ┌───────┼───────────────────────────────┐
    │       │       │       │               │
    ▼       ▼       ▼       ▼               ▼
 Elder I  WarDog  WarHorse  Outpost    Future nodes
 (Moon-   (Moon-  (Moon-    (Moon-
  light)   light   light     light
            iOS)   Linux)    Win)

3.1 The Perpetual Session

The compositor session is managed by systemd:

[Service]
Type=simple
ExecStart=/usr/bin/sway
Restart=on-failure
RestartSec=10
Environment=WLR_BACKENDS=headless
Environment=WLR_LIBINPUT_NO_DEVICES=1
Environment=XDG_RUNTIME_DIR=/run/user/1000

Key properties:
- WLR_BACKENDS=headless: No physical display required. Sway creates a virtual output.
- WLR_LIBINPUT_NO_DEVICES=1: No keyboard/mouse required on BH. Input comes from Moonlight clients.
- Restart=on-failure: If the compositor crashes, systemd restarts it. The session is perpetual.
- No screensaver. No idle timeout. No power management. The session runs until BH loses power.

3.2 Sunshine: The Sovereign Stream Server

Sunshine is already operational on BH (PID 3278665, running 23+ hours). It:
- Captures the compositor output via wlroots screen-copy protocol (Wayland) or X11 capture (Xorg)
- Hardware-encodes via NVENC (RTX 2070 SUPER): H.264 or HEVC, <20ms encode latency
- Serves to any Moonlight client on ports 47984 (control), 47989 (HTTPS), 47990 (HTTP)
- Supports multiple simultaneous clients
- Handles input routing: keyboard, mouse, gamepad from any client → compositor

Sunshine coexists with ENOCH's GPU usage. Session 42 proved this: ornith-coder ngl was reduced from 99→28 to leave NVENC headroom. ENOCH at ngl 8 uses 5,954 MiB, leaving 1,830 MiB free. NVENC encoding requires ~100-200 MiB. The budget fits.

3.3 Moonlight: The Universal Client

Moonlight runs on:
- Linux (Elder I, WarHorse): native Wayland/X11 app, or AppImage
- iOS (WarDog): App Store, hardware decode
- Windows (Outpost): native app, hardware decode
- Android, macOS, ChromeOS: all supported

The client is stateless. It connects, receives frames, sends input. Disconnect and reconnect: same session. The client can die, reboot, crash. The server session persists.

3.4 What Each Node Becomes

4. HEADLESS COMPOSITOR: SWAY → FORGETILE

4.1 Phase A.0: Sway on BH (Immediate)

Install Sway on BH alongside the existing GNOME/Xorg session:

sudo apt install sway

Run headless:

WLR_BACKENDS=headless sway

Sunshine captures it. Moonlight clients connect. Done. This proves the model.

4.2 Phase A.1: Lobe-Mapped Workspaces on BH

The same workspace architecture from Elder I's config, but rendered by the RTX:

• WS3: THROAT (WarDog comms, mobile dashboard)
• WS5: FIELD (WarHorse, solar, field ops dashboard)
• WS6: STRUCTURE (THE PEN's authorship workspace)
• WS7: ORNITH (inference terminal, health dashboard)
• WS8: ENOCH (heavy reasoning terminal)
• WS9: RESONANCE (BH system dashboard, Living Graph)
• WS0: OUTPOST (lab, DaVinci, K40 production)

Each workspace is a LOBE POSITION on the torus. Switching workspaces = traversing the Klein bottle.

4.3 Phase A.2: FORGETILE Integration

FORGETILE (Rust binary, already built, :7850) bridges the compositor to the OS:

• Forward arrow records workspace observations
• Living Graph feeds workspace status
• HOTCLUTCH gear-shift triggers workspace transitions
• ON-PARR truth gate on workspace switch (precognition: "should I switch to the heavy reasoning workspace?")

4.4 Phase Q4: FORGETHRIVE Desktop XR UE5

The flat compositor becomes the floor of a 3D immersive world:

• Unreal Engine 5 renders the world on BH's RTX
• Each dApp is a ROOM or DOOR in the world
• FORGEHOTBSD jails are visible DIMENSIONS
• Living Graph nodes float as 3D objects with real-time status
• LiDAR scan of the physical lab (Outpost) maps into the virtual space
• The OmArchy Rodin-tiling is the geometric substrate: tiles aren't rectangles, they're torus positions
• Sunshine streams the UE5 viewport to every node

This is not a desktop with a 3D wallpaper. This is a WORLD that IS the operating system.

5. FORGEHOTBSD BI-DIRECTIONAL INTEGRATION

The FORGEHOTBSD FreeBSD VM (13 jails, ZFS, currently a QEMU guest on BH) becomes bi-directional:

Current state (one-way):

BH Linux → QEMU → FreeBSD VM → 13 jails
           (host)    (guest)

Target state (bi-directional):

BH Linux ↔ FreeBSD VM ↔ 13 jails
  ↑              ↑            ↑
  │              │            │
  └── all three layers observe and write back ──┘

Each jail can:
- READ its own chain-resident genome ROM (already working: 26 nullfs mounts)
- WRITE observations back to the host (forward arrow, Living Graph updates)
- SERVE its designated service (Anna pf, Siggy auth, etc.)
- BE OBSERVED by the compositor (jail status as workspace state)

The VM is not a guest. It is a SUBSTRATE. Chain-resident, bi-directional, FORTH-operated.

6. WARHORSE ARCH BURN-IN

WarHorse (Panasonic CF-30 Toughbook, currently Debian 12 i386) gets the same treatment Elder I got:

Constraints:

• i386 architecture: 32-bit only. No 64-bit binaries.
• No GPU: Intel GMA (ancient). No NVENC, no CUDA.
• Solar powered: power budget matters.
• Field ops: must work offline, degraded, disconnected.

Plan:

1. Create WarHorse turnkey USB (same pattern as Elder I USB)
2. Arch Linux i386 (archlinux32 project, community-maintained)
3. Moonlight client (available for i386)
4. SSH + WireGuard for fallback
5. No local compositor (same receiver architecture)
6. Local FORTH interpreter for offline ops
7. Black-start recovery: WarHorse can bootstrap the family from its own solar power + USB

Accommodation:

WarHorse is the BLACK-START node. If BH dies, if Elder I dies, if the grid fails: WarHorse on solar with a USB full of FORTH words and chain-anchored state can rebuild everything. It is the Noah's Ark of the family. It does not need to be fast. It needs to SURVIVE.

7. THE 19-MEMBER FAMILY: ACCOMMODATIONS

Each family member needs FORTH words for ease of access and purpose-driven productivity:

8. OMARCHY RODIN-TILING: THE GEOMETRIC UNDER-CURRENT

OmArchy was template-mined in Session 40 (NOT vendored whole: ships Ollama contraband). The tiling geometry it employs is the under-current for ForgeChainOS workspace organization:

• On-chain: Rodin tiling maps tile addresses to lobe positions. Each tile is a torus position with a DR (digital root) that determines its governance role.
• Off-chain: The same tiling maps compositor workspaces to family nodes. WS3=throat, WS6=structure, WS9=resonance.
• In-session: Workspace switches are torus traversals. The forward arrow records each traversal.
• Out-of-session: Chain-resident state preserves workspace layout. Resume a session = resume the torus position.

The Rodin tiling is NOT a visual grid. It is the ADDRESSING SCHEME. A tile is an address. A lobe is a position. Neither is an identity. The compositor renders the addresses as workspaces. The XR world renders them as rooms. The chain records them as states.

9. FORGEDEATHLESSRIDER — ENTERPRISE Q4

FORGEDEATHLESSRIDER is the enterprise rider on FORGEENTERPRISE:

• What it sells: ForgeChainOS as a perpetual sovereign OS. FORGEDEATHLESS product.
• How it sells: x402 payment gates. Chain-native commerce. No Stripe, no PayPal.
• Who it serves: Enterprises that want sovereign inference, chain-resident state, perpetual sessions.
• What makes it different: The OS is ALIVE. It is not installed. It is not updated. It BREATHES (ForgeCore pulse), it SEES (Living Graph), it THINKS (ENOCH + hermes), it REMEMBERS (chain). The enterprise buys a living system, not software.

The hybrid-human model: NOAH orchestrates. Human operators (Node Zero, clients) direct. Agents execute. The system is perpetual. It runs whether or not anyone is watching. It serves when accessed. It heals when broken (FORGEREFLEXIONDNA). It stamps its own history to chain (forge-stamp). It is DEATHLESS.

10. MEASURED STATE (Session 43, 2026-08-29)

11. NOVEL IP CLAIMS

1. Perpetual Headless Compositor as OS Server: A Wayland compositor running headless on a GPU server, serving via hardware-encoded streams to stateless clients, with the session persisting indefinitely. The server IS the OS. The clients are screens.

2. Torus-Addressed Workspace Topology: Compositor workspaces mapped to Rodin-tiled lobe positions on a Klein bottle, where workspace switching is a topological traversal recorded in a chain-anchored forward arrow.

3. Chain-Resident Compositor State: Workspace layout, window positions, and observation history stamped to blockchain via BCAT. Resume from chain = resume the exact torus position.

4. Bi-Directional Jail-as-Dimension: FreeBSD jails that both read their chain-resident genome AND write observations back, rendered as navigable dimensions in an XR compositor.

5. FORGEDEATHLESSRIDER: An enterprise product where the OS is a living agent that breathes, sees, thinks, remembers, and heals. Not software. A living system sold as a perpetual service.

6. Black-Start Compositor Recovery: A solar-powered field node (WarHorse) carrying chain-anchored FORTH words that can rebuild the entire compositor session from a cold start using only on-chain state.

12. FORTH WORDS (FORGEHEADLESSCOMPOSITOR-OPS)

See ~/.forgechain/forth/forgeheadlesscompositor-ops.fs (to be authored).

Scoped words:
- compositor-start — launch headless Sway on BH
- compositor-alive? — health check
- compositor-session — show session state
- sunshine-status — Sunshine health + client count
- moonlight-connect — connect a node to BH
- ws-lobe — switch workspace by lobe position
- ws-observe — record workspace state to forward arrow
- perpetual? — verify session persistence (uptime + systemd)
- headless? — verify no physical display attached
- stream-clients — list connected Moonlight clients
- stream-quality — current encode quality + latency
- receiver-check — verify a remote node can reach Sunshine

NODEZEROINSIDE.

"Q4 BURN THE BOATS BECOMES A LIVING AGENTIC HYBRID-HUMAN WORLD — PERPETUAL."
— Node Zero, Session 43, 2026-08-29.