Skip to content
How PULSE is built

How PULSE is built

For administrators and developers. PULSE is application code only: a Go gRPC backend (grpc/) and a Flutter client (flutter/) for web, Linux and Android. The platform around it lives in other Runink repositories:

  • TIDE runs the local dev loop (tide dev), the deploys, the operator that reconciles a PULSE instance (in the pulse-system namespace), the image builds and the shared model weights.
  • The libraries security, mesh, inference, store, crawler, billing and ui supply authentication and sealing, interceptors and self-healing, the inference wrappers and the plan gate, persistence, headless web research, usage counting, and the shared pages (Subscription, Profile, Admin, Data sources).

One process, one port

pulse-server serve is one Go process listening on one port. A multiplexer splits that port in two:

  • Connections with content-type: application/grpc go to the gRPC server.
  • Everything else goes to an HTTP handler: gRPC-Web for browsers, /health, generated media, the voice endpoints, the sign-in and OAuth callbacks, the podcast feed and the website-form endpoint.

PULSE ships as an Android and iOS app. The backend serves no web bundle, so browser callers are cross-origin: set CORS_ALLOWED_ORIGINS (see the admin guide). Every HTTP endpoint is listed in the API reference; every gRPC service in the API reference.

Every call goes through the same chain

gRPC calls pass through the same interceptors in the same order: panic recovery, optional per-caller rate limiting (off unless PULSE_RATE_RPS is set), request logging, then authentication and authorization. Every method needs a valid session except sign-in and the model status; the caller’s role is checked against each method. Streaming calls also get serialized sends and a heartbeat, which keeps long generations alive through proxies.

AI

All AI runs on the platform’s own inference server (mistral.rs); PULSE calls no outside AI service, and it reads product facts straight from files. See Sovereign inference. What a model proposes passes the plan gate before it is kept.

Where data lives

  • PULSE’s appfs root holds all its data: every table (append-only tablelog), account, session and media file, sealed under PULSE’s own key on the in-cluster object store. There is no database. One writer, so a deployment runs one backend instance.
  • Tokens and passwords of connected accounts are sealed, column by column, before they are written (TIDE_ENVELOPE_KEK is required).
  • The app root holds sessions, generated media and the memo cache, each sealed. The server does not start if it cannot mount it.

Configuration, switches and operations are in the Admin guide; building and calling the API in the Developer guide.