Your comms. Your ops. Your server.
LynxDock is a self-hosted communication and tactical operations platform for gaming organizations — chat, voice, and a live tactical command board in one deployable unit, running on hardware your community owns.
A live tactical operations center.
Zones, unit nodes, routes, objectives, orders, and readiness — synchronized in real time across every connected member. Fleet admirals run the op from the board; wings see orders as they're issued.
A staged operation on the live board: a command tree over two wings, rally / danger / attack / exfil zones, and three operation routes — assault, recon, and medical — each with its own symbology.
Routes up close: named waypoints with types and statuses, waypoint-by-waypoint progress, and the commander's rollup tracking every route on the board.
Orders are issued from the board and land beside the picture they describe — objectives, wings, and routes each get their own panel on the same surface.
Briefings, wing channels, and comms discipline.
Channels, multi-party voice, and presence with your command structure visible at a glance — in the same app as the tactical board.
One process. One file. Your hardware.
The Server Host is a dedicated owner console. A calm first-run wizard creates your server without config files or terminal commands, then an Overview command center gives you a health verdict, a readiness score, and one-click fixes. Manage members, roles, channels, invites, backups, and voice; check reachability with a real round-trip proof; and read plain-language connection help — for local testing, LAN parties, or friends over the internet.
A real application, under active construction.
Infrastructure is complete and the desktop app is taking shape. Here's what runs today — and the framework the rest is built on.
Pushed the local messaging slice — edit + search work now.
you · 2h · edited
Unread counts and day separators are in.
you · 1h
Next up: reactions and mentions.
you · just now
Chat, voice, presence, and a live tactical board.
The desktop app now runs against a real self-hosted server: synced channels with replies and search, multi-party voice, live presence with custom status, and Squadron Control — a tactical operations board with routes, orders, and replay, consistent across every connected member. All of it is in active development and verified end to end as it lands.
Squadron Control
A live tactical board: units, wings, routes with waypoints, zones, objectives, orders, alerts, replay, and undo — synced to every client.
Messaging
Server-synced channels with replies, reactions, rich formatting, search, and an offline outbox that delivers exactly once on reconnect.
Voice
Voice rooms with mute/deafen, device selection, and screen sharing over a self-hosted media plane — with NAT traversal handled for you, no LiveKit or TURN setup required.
Roles & channels
Server-wide roles with capability tokens, custom colors and ordering, multiple roles per member, and first-class text/voice/tactical channels grouped into categories.
Settings
A 20-category, searchable settings system — server-persisted per account, privacy-first defaults, Basic and Advanced modes.
Genesis UI
LynxDock's own component framework: design tokens, a theme engine, and a Tailwind preset.
Rust core
A protocol-first Rust server and Tauri desktop shell; TypeScript types are generated from the Rust protocol so client and server can't drift.
Server Host
A dedicated owner console: guided setup, an Overview command center, members, roles, channels, invites, backups, connectivity, and diagnostics — self-hosting without config files.
Tested seriously
Reconnect, offline replay, multi-client convergence, undo, and permissions covered by automated tests and live multi-account verification.
Studio
GSpec Studio validates a specification entirely in the browser using the shared core.
Communication you actually own.
The constraints we design LynxDock around — the reason it feels different to run.
Own your data
Local-first today, self-hostable tomorrow. Your accounts, messages, and files stay with infrastructure you control.
Performance matters
A Rust core and a lightweight desktop shell. Fast to launch, calm to use, light on resources.
Open architecture
Spec-driven and generated end to end. Wire types come from Rust; the site comes from the spec.
Privacy by default
No ads, no tracking, no telemetry required. Restraint is a feature.
Spec-driven, polyglot, generated end to end.
A versioned specification feeds the infrastructure layer, which supports one product monorepo spanning Rust and TypeScript.
- GSpecshipped
The Genesis Specification — one versioned source of truth in YAML + JSON Schema.
- Bootstrapshipped
The compiler: parse → validate → IR → generate ecosystem artifacts.
- Release Toolsshipped
Turns a GitHub release into a signed releases manifest.
- Websiteshipped
This static site, consuming generated data.
- sharedshipped
Base types, helpers, logging, config, errors.
- protocolshipped
Canonical wire types, generated Rust ↔ TypeScript via ts-rs.
- genesis-uishipped
The component framework: tokens, theme engine, Tailwind preset.
- desktopshipped
Tauri app: workspace, identity, settings, local messaging.
- studioshipped
GSpec Studio — in-browser spec validation.
- pluginsshipped
Plugin SDK: manifest + capability model.
- aishipped
Agent & tool contracts.
From foundation to a full platform
LynxDock is built in the open, tracked as epics. Foundation, messaging, networking, voice, tactical operations, and the Server Host are done; communities and roles are landing; release distribution is in progress.
- Epic 0Completed
Foundation & Runtime
The infrastructure the whole platform is built on: a polyglot monorepo, generated protocol types, shared libraries, CI, and a publish-gated release pipeline.
- pnpm + Turborepo monorepo, Rust Cargo workspace
- @lynxdock/shared, @lynxdock/protocol (Rust ↔ TypeScript via ts-rs)
- @lynxdock/gspec with a Golden-IR contract test and browser support
- CI (JS + Rust) and Changesets release pipeline
- Epic 1Completed
Workspace & Identity
The top-level container and who you are, stored locally. Everything else hangs off the workspace.
- Local workspace (name, icon) as the root container
- Profile: display name, avatar color, Rust-side validation
- Settings applied live: theme engine, reduced motion, privacy status
- Desktop sidebar: Workspace → Profile → Settings
- Epic 2Completed
Local Messaging
A full local-first chat client — the messaging layer everything networked now builds on. Workspace → Channel → Message.
- Channels and messages: compose, edit, delete
- Reactions, @-mentions, and local file attachments
- Full-text search (SQLite FTS5) with channel and attachment filters
- Unread counts, previews, day separators, relative timestamps
Next: Now synced over the network in Epic 3.
- Epic 3Completed
Networking
Messaging made real-time over a self-hostable server: a WebSocket hub, live sync, and resilience on flaky connections.
- WebSocket hub transport + RPC, Argon2 auth, presence
- Server-backed read state with live cross-device sync
- Offline outbox: queues while disconnected, drains on reconnect
- Self-hostable Rust server with schema migrations, backup, export & import
- Network posture: invite-gated registration, per-IP auth rate limits
Next: Hardened to the beta bar by the 2026-08 security pass (attachment-path fix, RPC rate limiting, supply-chain gate).
- Epic 4In Progress
Communities, Servers & Roles
Persistent self-hosted communities with a real permission model: server-wide roles, first-class channels, and owner-managed membership.
- Server-wide roles: named, colored, ordered, with capability tokens (forward-extensible; unknown tokens round-trip)
- Multiple roles per member; a protected Owner that always keeps administrator
- First-class channels + categories — text, voice, and tactical kinds
- Member administration + role assignment, capability-gated in the client
- Invite-gated membership; the server is the single authority (client never trusted)
Next: Friends, direct messages, and cross-server presence are next.
- Epic 5Completed
Voice & Screen Sharing
Real-time voice and screen sharing over a self-hosted SFU (LiveKit), with a clean two-plane split between control and media — and NAT traversal that actually works, proven end to end.
- Control plane: live call roster with join / leave / mute / deafen / screen-share state
- Audio media, active-speaker ring, input/output device pickers, autoplay unblocking
- Screen sharing: publish, subscribe, multi-tile viewer
- Self-hosted TURN (LynxDock-built coturn) with room-scoped, time-limited credentials
- Real RFC 5766 relay allocation proven in CI; unauthenticated allocation denied (no open relay)
Next: File transfer over the same media plane is planned.
- Epic 6Completed
Tactical Operations
Squadron Control — a live tactical operations board in the same app as your comms. A shared operating picture that stays consistent across every connected member.
- Command tree, wings, unit nodes, zones, routes with waypoints, objectives, orders, alerts
- Owned layered sketches, tactical graphics, on-board measurements, and temporary marks
- Per-viewer visibility with label/color editing; working → Mission promotion
- Commander archive/fade with a replay-visible record; Mission Log + after-action review
- Real-time convergence across clients, verified end to end (ADR-0027, closed at Sprint 7)
- Epic 7Completed
Server Host
A dedicated owner application that makes self-hosting approachable — create and run a real LynxDock server without config files or the terminal.
- Overview command center: health verdict, readiness score, one-click fixes
- Members, roles, channels, and a server profile (icon, banner, rules, landing channel, join preview)
- Invites, online backups & recovery points, connectivity, and diagnostics
- Make Reachable with round-trip proof; honest network posture (double-NAT / CGNAT / manual)
- Voice/TURN control with verified component acquisition; live health, lifecycle, and recovery
Next: V1 Server Host parity reached; owner UI/UX acceptance passed (2026-08).
- Epic 8In Progress
Release & Distribution
Getting trustworthy builds onto machines: CI installers, a verified component supply chain, and Windows code signing.
- CI-built Windows installers (MSI + NSIS) for the desktop app and the Server Host
- ed25519-signed component manifest + verify-before-execute; public component origin
- Windows Authenticode via Azure Artifact Signing wired into CI (fail-closed, gated)
Next: Owner Azure provisioning enables the first signed release; an auto-updater follows.
- Epic 9In Progress
Mission Control & Observability
One honest view of the whole system: a shared status contract, a live hub every module reports into, and an event timeline — so health, activity and progress are observable rather than guessed at.
- System status contract with a worst-wins health roll-up, generated to a single artifact
- Mission Control hub: modules, metrics and entities aggregated into one state
- Live server feed over the WebSocket hub — connections, active voice rooms, host CPU/RAM
- Event bus and timeline: retained event history replayed into a live activity log
Next: Dashboards, an integration layer, and AI Workforce views are designed and next.
- Epic 10Planned
AI & Automation
Agents and tools wired into the workspace, built on the @lynxdock/ai tool contracts.
- Tool contracts
- Workspace-aware agents
- Epic 11Planned
Plugins
Third-party extensibility via the @lynxdock/plugins SDK — a capability model and plugin host.
- Plugin SDK & manifest
- Capability model
Next: The point at which the packages begin publishing to a registry.
- Epic 12Planned
Studio
The engineering environment, including GSpec Studio, matured into a real tool for building on the platform.
- GSpec Studio
- In-browser spec validation
Latest updates
What we built, what problem it solved, and what we learned - published as we go.
Squadron Control grows an operations layer
In one focused stretch, the tactical board went from an empty section of the new client to a full operations platform: units, wings, orders, alerts, zones, formations, snapshots, mission templates, undo, a permanent audit log with time-travel replay - and then an operations layer on top: multi-waypoint routes you can edit like vector paths, advance in real time, and command from a live roll-up. Here's what we built and the architecture that made it fast to build.
7 min read
A settings system built like a platform, and a week of polish
Settings grew from four toggles into a 20-category, searchable system with Basic and Advanced modes - where every setting the platform will ever expose is declared, and the ones whose subsystems haven't shipped are shown honestly as planned instead of faked. Plus: replies, custom status, readable errors, and an accessibility and performance pass across the client.
5 min read
LynxDock applies for NSF research funding
We've submitted a Project Pitch to America's Seed Fund (NSF SBIR) to fund research into the hard problems under LynxDock: real-time state synchronization, large multi-party voice, and self-healing operability on affordable self-hosted hardware.
2 min read
Follow along as LynxDock takes shape.
The alpha desktop app is in active development (internal build 0.1.0-alpha). Grab it, watch the roadmap, and follow the work on GitHub.