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.
A calm first-run wizard creates your server without config files or terminal commands. Dashboard, admin controls, readable live logs, and 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 — presence-aware throughout.
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 guided setup wizard, dashboard, admin controls, and readable live logs — 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 and identity are done; messaging is in progress; the rest is planned.
- 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 syncing over the network in Epic 3.
- Epic 3In Progress
Networking
Making messaging real-time over a self-hostable server: a WebSocket hub, live sync, and resilience on flaky connections.
- WebSocket hub transport + RPC
- Server-backed read state with live cross-device sync
- User display-name resolution over the wire
- Offline outbox: queues while disconnected, drains on reconnect
- Self-hostable server (Rust / axum) with backup, export & import
Next: Built on the protocol contracts already generated in Epic 0.
- Epic 4Planned
Communities & Servers
Friends, servers, and shared channels over the network, with membership and roles.
- Friends & presence
- Servers & membership
- Roles & permissions
- Epic 5Completed
Voice & Screen Sharing
Real-time voice and screen sharing over an SFU (LiveKit), with a clean two-plane split between control and media — delivered across five phases, hardening included.
- Control plane: call roster with join / leave / mute / screen-share state broadcast live
- Room-scoped access tokens and TURN credentials issued server-side
- Audio media: microphone publish, remote audio, active-speaker ring, deafen
- Input and output device pickers, with autoplay unblocking handled
- Screen sharing: publish, subscribe, and a multi-tile viewer
- Hardening: connection state, classified errors with retry, per-participant quality dots
Next: File transfer over the same media plane is next (Version 2.3).
- Epic 6Planned
AI & Automation
Agents and tools wired into the workspace, built on the @lynxdock/ai tool contracts.
- Tool contracts
- Workspace-aware agents
- Epic 7Planned
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 8Planned
Studio
The engineering environment, including GSpec Studio, matured into a real tool for building on the platform.
- GSpec Studio
- In-browser spec validation
- 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
- Commander reporting: squadrons and operations, created from the desktop app
- Event bus and timeline: retained event history replayed into a live activity log
- Studio session observer: development sessions reported into the same hub
Next: Dashboards, an integration layer, and AI Workforce views are designed and next.
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.