Zeron

Zeron is a ground-up Rust rewrite of a multi-device controller for coding agents such as Claude Code, Codex, Cursor, Devin, Grok, Hermes, Pi, and Antigravity. Every device runs a small local engine daemon that stores its own sessions on disk, so a fresh install starts fully local-only with no account or network connection required. A native gpui desktop UI (or headless mode) talks to that engine over the same typed RPC whether it is running in-process or as a separate daemon.

Signing in unlocks optional multi-device sync: session transcripts and a workspace registry are stored as Loro CRDT documents, replicated through Cloudflare Durable Objects, so an agent kicked off on one machine (say, an always-on VPS) can be followed, steered, or interrupted from a laptop later. Sends, steers, and interrupts are durable command-queue entries in the session doc, so actions taken while offline queue up and execute once a host device is available.

Beyond just streaming agent output, the engine owns terminals (via portable-pty), git repositories and worktrees, checkout-diff sync, and file uploads, which is what powers the live branch-diff sidebar shown while an agent works. The desktop UI is built on a forked, GPU-memory-bounded version of Zed’s gpui with backdrop blur and edge-fade effects for its glass-panel sidebar, while all device-side logic — the harness adapters, the CRDT mirror layer, and the RPC surface — is Rust; only the optional sync backend (Durable Objects, WorkOS auth, R2 attachments) is TypeScript.

Devices signed into the same synced account are trusted peers for remote workspace access — a controlling device can list, read, and write files on the device that owns a checkout (excluding .git), which makes Zeron most useful for individuals or small trusted teams who want one native surface for driving several different coding-agent CLIs instead of juggling each tool’s own UI.

What You Get

• A native Rust engine daemon that runs Claude Code, Codex, Cursor, Devin, and other coding agents through pluggable stream-json/JSON-RPC harness adapters.
• A gpui-based desktop UI with an attention-sorted session sidebar, live branch-diff view, and space-based (device + folder) workspace organization.
• Optional CRDT-backed multi-device sync via Cloudflare Durable Objects, so agent sessions and the workspace registry can follow you between machines.
• A single zeron binary that runs headed (desktop app) or headless (zeron headless), plus a CLI for daemon management, login/logout, and updates.
• Built-in terminal, repo/worktree, and file-upload handling so agents operate directly on your checkouts with diff sync back to the UI.

Common Use Cases

• Kicking off a long agent run on a remote or VPS engine and checking in from a laptop later.
• Working fully offline and local-only with no account, for privacy-conscious individual developers.
• Standardizing on one control surface for multiple coding-agent CLIs instead of each tool’s own UI.
• Reviewing an agent’s in-progress file changes via the live diff sidebar before anything is merged.

Under The Hood

Architecture Zeron is organized as a Cargo workspace of focused crates around a clear engine/UI split: zeron-engine runs sessions, terminals, repos/worktrees, and auth as a pure Rust daemon that is fully functional headless, while the zeron app crate provides a gpui viewport that talks to that engine over a typed RPC (zeron-rpc) regardless of whether the engine is in-process or a separate daemon on the same host. State is modeled almost entirely as Loro CRDT documents — a per-chat session doc (transcript plus a durable command queue) and a per-profile workspace registry doc — with zeron-doc providing incrementally-updated typed mirrors of those docs instead of full re-hydration on every change, directly targeting a known O(transcript) inefficiency in the project’s predecessor. Optional sync is layered on top via an edge tier (edge/, TypeScript, Cloudflare Durable Objects for ChatRoom/DeviceRoom plus R2 and WorkOS auth) that the Rust zeron-sync crate speaks over a room protocol; local-only profiles persist the identical doc schema without ever joining a room, so the sync boundary is additive rather than load-bearing for core functionality.

Tech Stack The device side is Rust (edition 2024) on a Tokio async runtime, using loro/loro-protocol for CRDT sync, a forked gpui (from Zed, via the project’s own zeron-ui/zui forks) for native rendering with custom backdrop-blur and GPU-memory-bounding work, rusqlite for local snapshot storage, portable-pty and alacritty_terminal for embedded terminals, reqwest with rustls for networking, and clap for the CLI. The optional sync backend is a separate TypeScript package (edge/) deployed as Cloudflare Workers/Durable Objects with wrangler, sharing the loro-crdt/loro-protocol wire format with the Rust side byte-for-byte. Release builds use thin LTO with stripped symbols, and CI covers Windows, macOS (TestFlight), Linux preview builds, and UI tests as separate GitHub Actions workflows.

Code Quality The codebase shows unusually thorough module-level documentation — source files like crates/engine/src/sessions.rs open with multi-paragraph doc comments explaining not just what the module does but why specific design decisions (like deliberately not porting a stall watchdog) were made. Error handling uses typed thiserror error enums (EngineError, DocError) rather than string errors, and tracing is used for structured logging throughout. Tests are extensive across the Rust crates and the TypeScript edge package has its own Vitest unit and Cloudflare Workers-runtime test suites, backed by dedicated CI workflows for Windows, macOS, and UI regressions.

What Makes It Unique Most coding-agent tooling either is a single agent’s own CLI/IDE integration or a thin multi-agent aggregator; Zeron instead builds a full local-first data layer — CRDT documents that are identical whether or not sync is enabled — so that multi-device control, live diffing, and offline command queuing are native properties of the session model rather than bolted-on networking. Pairing a hand-tuned, GPU-memory-bounded fork of Zed’s gpui renderer with a Rust engine that treats headless operation as a first-class mode (not a stripped-down alternative to the desktop app) is an uncommon combination for this category of developer tool.

Self-Hosting

Licensing Model MIT licensed — all features, including multi-device sync, are available with no license keys or paid tiers; the only distinction is whether you sign in to enable optional sync infrastructure.

Self-Hosting Restrictions None found — there are no ee//enterprise/ directories, license-check code, or feature flags gating functionality behind a paid plan.

License Key Required No — the project has no license-key mechanism. The self-hosted sync backend (Cloudflare Durable Objects/Workers) is currently a development/deployment seam for the maintainers rather than a documented, supported self-hosting contract for end users.