Docs menu

dotwire

Early release (v0.2). APIs and deployment guidance may still change, and dotwire isn't production-hardened yet, so evaluate it carefully before relying on it. Feedback and issues are welcome at github.com/pasztor-mark/dotwire.

dotwire is a self-hosted chat layer that you embed in your own application. Your app keeps owning its users and signs RS256 JWTs for them. dotwire verifies those tokens, delivers messages in realtime, persists them, and records a tamper-evident audit log.

dotwire ships an HTTP API, a realtime hub, and SDKs. It does not ship a chat UI, so you build the interface your product needs.

It runs as a single .NET 10 Native AOT binary, with NATS JetStream for delivery and durability and TimescaleDB (PostgreSQL) for message history.

Highlights

  • Host-owned identity. dotwire has no user table, signup flow, or password store. It verifies tokens your backend mints, then checks roles and room membership in its own tables. See Auth.
  • Acks on durable receipt. A send returns 202 Accepted once JetStream has stored the message. Postgres ingestion runs in the background. See Architecture.
  • One binary, three roles. All runs everything in one process. Api and Gateway split the REST surface from the socket-holding nodes when you scale out. See Deployment.
  • Encryption at rest. Message content is encrypted with AES-256-GCM before it reaches JetStream or Postgres. See Encryption and retention.
  • Tamper-evident audit log. Admin actions and audit reads land in a hash-chained, append-only log that you can verify. See Audit log.
  • Compliance surface. Redaction, DSAR export, and configurable retention are available through the admin API and both host SDKs. See Compliance.
  • Moderation hooks. Optional presend and postsend hooks let your host reject, rewrite, or review messages. See Moderation webhooks.
  • Two live read paths. Apps use SignalR over WebSockets. Agents and scripts can use Server-Sent Events. See Hub events and HTTP API.

Who it's for

The primary audience is a host application, typically a SaaS backend, that wants embedded chat without a per-MAU vendor bill and without keeping a second user table in sync. Because dotwire owns no identity, integration means pointing it at your signing key, not migrating user records.

Agent harnesses that need an observable message bus with humans in the loop are a supported secondary audience. Where a design choice trades one audience against the other, the host application wins.

What dotwire doesn't do

These are deliberate exclusions, not missing features:

  • End-to-end encryption. dotwire's threat model is stolen disks and database leaks, and the server must read content to fan it out.
  • AI moderation. The presend hook is the extension point for your own moderation.
  • Sharding. The schema includes room_id on every hot-path query, but dotwire doesn't shard.
  • Multi-region deployments.
  • Federation with other servers.
  • gRPC. The wire protocols are SignalR over WebSockets and REST.
  • An admin dashboard UI. dotwire ships admin, DSAR, and redaction APIs; you build or buy the UI.
  • Redis. NATS JetStream already covers fanout, ephemeral pub/sub, and persistence acks.

Docs

Start here

  • Quickstart: run dotwire with Docker Compose, mint a token, and send a first message.

Concepts

Guides

SDKs

Reference

The source and the normative specs (PRODUCT.md, ARCHITECTURE.md, AUTH.md, COMPLIANCE.md) live at github.com/pasztor-mark/dotwire.