Skip to content

6.0.0

Choose a tag to compare

@github-actions github-actions released this 15 Nov 21:30

Gupt 6.0.0 — Rabta

We moved Gupt off Nostr relays. Your data now lives on your device, and relays are dumb, replaceable pipes.

This is the biggest change in Gupt's history. 6.0.0 replaces the entire relay and file-storage layer with Rabta, a protocol built from scratch for Gupt.

If you take one thing from these notes: gupt.app keeps a full copy of your account. Relays no longer hold your life; they only help your devices stay in sync.

Why we left Nostr relays

Nostr was a useful starting point. It was never designed to be the storage and sync layer for an encrypted privacy suite. Six problems kept biting us, release after release.

1. WebSockets

Nostr is built on long-lived WebSocket connections. Mobile browsers sleep, proxies drop idle sockets, networks change, and every hiccup turns into reconnect storms, missed events, duplicated subscriptions and "why didn't that message arrive?".

Rabta is plain HTTP: one request, one response, retries with exponential backoff, and optional SSE for live updates. It behaves like a normal API, including on bad networks.

2. Random limits

Every relay invents its own limits: filter count, event size, query window, rate limits, maximum results (often an arbitrary 1..100), how far back you can read, how much you can write. Code that works on one relay breaks on the next, and users pay the price.

Rabta has one documented API contract. Limits are explicit, reported by the node, and do not change depending on who you are or which relay you hit.

3. No storage upload

Nostr has no native file storage. We had to bolt on IPFS gateways and Originless upload servers, which meant more services, more failure modes, and attachments that could vanish independently of the message that referenced them.

Rabta stores files as encrypted, content-addressed blobs (RABTA1, SHA-256) on the same node as the events. One relay, one backup, one thing to run. Uploads go to every configured node in parallel, and downloads verify the hash.

4. Expiry timestamps weren't honored

NIP-40 expiration was optional in practice. Some relays kept expired events forever, some dropped events early, and clients could not depend on either. Expiry was a suggestion, not a guarantee.

Rabta enforces TTL at the node: 60 seconds to 300 days. Expired data is removed automatically. If we say an event is temporary, it is actually temporary.

5. Random paywalls

Paid relays, auth walls, "premium" write access, subscription tiers. Your notes should not stop syncing because a relay operator discovered a business model. Gupt's data layer cannot depend on someone else's pricing page.

Rabta has no accounts and no paywall built in. A node is storage you can run yourself for a couple of dollars a month.

6. Stupid web-of-trust requirements

Some relays only accept events from keys that follow the right people, belong to the right community, or pass a manual whitelist. Gupt is supposed to work for anyone with a keypair, not for members of a club.

Rabta verifies signatures and expiry, not social status. If you hold the key, you can publish.

The deeper reason

We could have patched around each of these problems. We decided not to, because Nostr lacks innovation and its direction is currently dominated by a couple of very loud voices who focus on everything except reliability. The ecosystem keeps re-litigating social feeds, clients and politics while the unglamorous parts — delivery, storage, expiry, uptime — stay broken.

We did not want to build Gupt's next five years on that foundation. So we wrote our own.

Enter Rabta

Rabta is an append-only, content-addressed sync protocol for signed events and encrypted files. It was built from scratch for Gupt, not adapted from a social protocol. It is corporate-free and always free: MIT OR Apache-2.0, no company behind it, no license keys, no "enterprise edition".

A Rabta node is one Rust + SQLite container. No separate database, no migrations, no message broker, no cloud dependency. It runs on a $2 VPS or a pod.

Nostr relays Rabta
Transport WebSockets HTTP + SSE
Files bolted-on gateways native encrypted, SHA-256 blobs
Limits per-relay and arbitrary one API, storage you control
Expiry optional, often ignored enforced, 60s–300 days
Access paywalls, whitelists, web of trust no accounts, no gatekeepers
Hosting varied one container, ~$2/month
Sync client re-implements peer-to-peer mesh, self-healing
Source of truth the relay your device

What this means for you

Your device keeps your data

gupt.app now keeps a 1:1 copy of your account in IndexedDB. Reads come from your device, not from a relay. Writes are signed, verified and stored locally first, then replicated in the background.

That gives you:

  • Instant, offline-first UI — no waiting on a relay round trip.
  • No data loss when a relay disappears — the relay is a copy, not the original.
  • No single point of failure — configure one node or several.
  • Your private data stays yours — messages, files, notes, passwords and bookmarks are still encrypted before they leave your device.

Seamless multi-device sync

Sign in on your laptop and your phone with the same account. Each device pulls the events and blobs it is missing, and the local-first engine converges them in the background. Add a local backup node as a sync point if your devices are rarely online at the same time.

Relays are dumb on purpose

A Rabta node stores signed bytes, answers queries, streams blobs, expires old data and replicates to peers. That is it. No feed algorithm, no social graph, no web of trust, no opinions about who you are. All of the logic stays in Gupt on your device. That is why a node fits in one container and costs less than a coffee.

Self-healing relay mesh

Point nodes at each other with SYNC and they reconcile what they are missing. Add a node, remove a node, lose a node for a week — when it comes back it catches up. There is no central hub and no leader.

More in 6.0.0

The protocol switch touched almost everything, so this release also includes:

  • A local-first sync engine with an outbox, relay acknowledgements, retries and per-relay health.
  • Chat, groups, profiles, feed, notes, passwords, bookmarks and invites all on Rabta collections (gupt/...).
  • Encrypted attachments uploaded directly to Rabta nodes, with SHA-256 verification and multi-relay fallback.
  • Expiring relay-backed invite links; temporary invites open without an account.
  • File + PIN sign-in.
  • Deterministic offline avatars.
  • Faster call setup (held-offer flow, ring on first host candidate, mic prewarm).
  • A copy-ready Docker/Podman command for a local backup node in Settings.
  • Denser conversation list and cleaned-up relay settings.
  • Removed: the entire Nostr/WebSocket transport, IPFS/Originless gateways, ephemeral share links, typing indicators, and legacy relay hints/gossip.

Upgrade notes

  • 6.0.0 is a breaking release. Identity moved from secp256k1 (Nostr) to Ed25519, and encryption to X25519. Signing in with the same anchors now creates a new Rabta identity. Nostr-era events, contacts and attachments are not migrated.
  • Relay URLs must be Rabta node URLs (http:// or https://). wss:// relays are no longer accepted. Set them in Settings → Relays.
  • Default relays are https://rabta.t3nk.com and https://1.rabta.space.
  • Old temporary share links are gone. Use the new expiring invite links.
  • Self-hosters: run a Rabta node, not a Nostr relay

Then add http://localhost:3232 in Settings → Relays. To allow remote access, change the mapping to -p 3232:3232 and put HTTPS in front of it.

Links


Gupt 6.0.0 — your device keeps the data, relays just move it.