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 thepulse-systemnamespace), the image builds and the shared model weights. - The libraries
security,mesh,inference,store,crawler,billinganduisupply 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/grpcgo 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_KEKis 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.