How many Chromium rendering engines does a developer desktop really need running at once?

Every time I fire up a typical desktop AI wrapper, before I even type a single token into the prompt box, Task Manager spawns 4 helper child processes and eats 800MB to 1.2GB of system RAM. Laptop fans immediately spin up. All this overhead just to render a text box, parse markdown, and stream SSE tokens from a local Ollama or vLLM instance.

A few days ago I dug into Scronkfinkle/byob [Bring Your Own Brain] on GitHub. It is a desktop AI companion built in pure Rust, zero Electron, direct GPU hardware rendering via egui and wgpu, with a built-in split-screen artifacts workbench and process isolation.

Here are my hands-on benchmark notes, architecture breakdown, and the real rough edges I ran into.

  1. Actual Memory Footprint and Measurement Method

One has to state measurement methods clearly, otherwise numbers mean nothing:

Linux PSS measurement: Tested on Linux via ps_mem. Cold boot idle sits around 41MB.
macOS 14 Apple Silicon: Activity Monitor reports 38MB resident memory. The 3MB delta is due to macOS including shared dynamic system libraries in resident accounting.
Under active workload: Loading a 200KB Markdown parsing document in the right artifacts panel with 30 chat turns in active history kept peak memory strictly under 85MB.
Binary footprint: Built via cargo build --release, the slim binary is only 13MB. The entire bundle with helper tools is around 58MB.
Smoothness: On a 120Hz display under Metal and Wayland, UI rendering syncs directly to hardware vertical refresh. No webview hydration delay or white-screen hiccups.

  1. Why Ditching Tokio for Blocking Threads Makes Sense Here

The agent engine lives in byob-agent. Most modern Rust networking tools reach for tokio and heavy async runtimes by default. Interestingly, byob takes the opposite route: lightweight synchronous blocking threads combined with cross-thread channels.

Looking into byob-agent/src/runtime.rs, the reason is straightforward: it is a personal desktop assistant, not an edge gateway serving 10,000 concurrent sockets. The thread pool is intentionally capped at 8 workers.

One thread blocks on the incoming SSE token stream from the model. Another runs tool execution. A fixed-capacity cross-thread channel passes structured event payloads between them.

Idle CPU hovers between 0% and 0.8%. In top, you barely see it. The only trade-off: during long context replays, the fixed-capacity event channel occasionally encounters backpressure, requiring manual channel buffer capacity adjustments.

  1. Tool Calling Fallback for Smaller Local Models [7B / 8B]

When connecting to Ollama at localhost:11434/v1 or standard OpenAI-compatible endpoints, smaller open-source models like Qwen2.5-7B or Llama-3-8B frequently stumble on strict JSON Schema function definitions. They drop closing brackets or output broken JSON.

If a client strictly demands standard tool_calls schemas, the turn fails completely.

byob includes a structured prompt degradation layer: when native function calling fails schema validation, it automatically injects XML markup into the system prompt and parses blocks from raw text client-side. This keeps agentic tool loops working reliably even on constrained laptop hardware.

  1. Sandboxed Execution with Bubblewrap on Linux

When letting an agent execute local commands or write files, raw shell access is dangerous. byob implements two defense lines:

Explicit visual diff card: Code additions and deletions are highlighted in red and green. A human mouse click is required before changes touch the disk, with turn-level undo available.
OS namespace containment: On Linux, it wraps subprocess execution using bwrap without needing a heavy Docker daemon:

bwrap \ --ro-bind /usr /usr \ --ro-bind /lib /lib \ --tmpfs /tmp \ --proc /proc \ --dev /dev \ --bind ./scratch ./scratch \ --unshare-all \ --die-with-parent \ python3 script.py 

Two real gotchas if you replicate this:

Omit --ro-bind /lib64 /lib64 on Arch Linux or lean Fedora setups; without a separate /lib64 directory, bwrap crashes immediately with ENOENT.
Never skip --proc /proc and --dev /dev. Missing /dev/urandom will cause the Python interpreter to silently lock up during startup imports without throwing any error.
--unshare-all cuts off network access by default. If your tool script genuinely needs outbound connectivity, you must explicitly pass --share-net.

  1. The Real Rough Edges

It is not a magic turnkey tool yet:

Upstream graphics hiccups: Upgrading to wgpu 0.20 caused occasional black-screen flicker when resizing windows under Arch Linux Wayland, forcing me to hold the dependency at wgpu 0.19.
CJK font fallback: egui built-in font sets do not include full CJK glyphs. You have to manually specify local TrueType font paths in config to avoid blank tofu squares.
Complex web artifacts: While it has experimental Servo integration for HTML rendering, heavy client-hydrated web apps can still cause timeouts or styling glitches. Electron still holds a big compatibility edge for complex JS-heavy widgets.
Conclusion

For a developer who primarily wants a fast, responsive, zero-Electron daily driver to talk to local Ollama models and review code diffs, having a 38MB native GPU client is a breath of fresh air.

I wrote up my full technical teardown, complete benchmark breakdown, and system configuration notes here for anyone interested: https://freeaidog.com/blog/byob-rust-gpu-desktop-ai-coworker-guide/

Has anyone else been testing pure native or immediate-mode UI frameworks for local LLM workflows? How are you handling sandbox isolation on macOS and Windows?