A leaderless coherent cache for teams running distributed Redis at scale — full Redis 8.4 semantics across any number of regions. Every node accepts writes. Exactly-once delivery lives in the data plane. AGPL or commercial.
Current version v1.1.3 · AGPL · Redis 8.4 wire-compatible
# macOS / Linux
brew tap swytchdb/tap
brew install swytchAlso via curl | sh and Docker (ghcr.io/swytchdb/swytch).
A working model of the engine, in your browser. Type Redis commands into either region, cut the link mid-write, and watch the causal-DAG merge reconcile both sides deterministically when it heals. Type HELP to begin.
A model, not the binary — the real engine speaks RESP on port 6379 with the full Redis 8.4 command set. The semantics shown are the documented ones: commutative merge, deterministic fork-choice, exactly-once delivery.
Every mutation produces an effect that carries pointers to the effects it observed. The dependency graph is the ordering. Replication has no leader because there is nothing to elect; merges need no coordination because the DAG orders them deterministically. Consistency comes from physics.
Effects you wrote are immediately visible where you wrote them. Causal time only moves forward. If A caused B and you've seen B, you've already seen A.
Any effect at node X reaches node Y within d(X,Y) + e — propagation delay, nothing more. There is no longer-tail "eventual" window beyond the speed of the network.
Two nodes observing the same tip set produce bit-identical state. Same function, same inputs, same answer, at every node.
Two writes arrive at two regions, two milliseconds apart. They are causally unrelated. Cassandra picks one; the other is silently overwritten by a wall clock. CockroachDB blocks until quorum can prove an order. Spanner pays the TrueTime wait.
Swytch records both, in their causal-DAG order, and converges. Each region remains its own writer within its light cone; the cones merge as they propagate. The application code stays simple. Exactly-once delivery lives in the data plane — no idempotency keys, no UUID column.
The behavior holds under fault injection. The TLA+ specifications are public. The Jepsen suite is reproducible.
# Two regions. No idempotency key. No UUID column.
client.SET("order:7841", payload)
client.XADD("events", *, status="placed")“Code for your deliverables instead of patching against failure modes.”
Three regions. Eight nodes per region. The same machines that already run the application. Identical spec for every system on the chart.
3 regions x 8 nodes · c5.4xlarge equiv. (16 vCPU / 32 GB) · 1 KB values · YCSB-B 95/5 · sustained QPS
At identical hardware and workload, every consensus-based system tops out around 500k QPS in multi-region — the quorum round-trip is the ceiling. Swytch commits locally, synchronously to subscribed nodes only, and the ceiling moves.
Both sides keep accepting writes: each region its own writer for the duration of the partition. They reconcile deterministically when the link heals: not by wall clock, not by last-writer-wins, but by the order the light cones imply.
No minority to block, no quorum to lose, no failover window.
Spanner slows in TrueTime wait + Paxos. CockroachDB waits on Raft round-trips. Postgres pays its toll by staying in one region. Cassandra and Redis A/A skip the toll entirely: they don’t commit cross-region, instead merging eventually.
Swytch commits to subscribed nodes only, locally, in sub-millisecond: fully convergent, no quorum, no leader.
Until today, the choice had to be between throughput and cross-region commit latency. Not anymore.
With Swytch, yesterday's "impossible" is today's base product.
Same RESPv2/v3 wire protocol on port 6379. Point your existing client at a Swytch instance and keep writing the code you were writing. Same wire protocol. Same RESPv2/v3. All Redis 8.4 commands. Existing client libraries connect unchanged; existing application code runs unchanged. Swap one hostname. Active-active multi-region, exactly-once delivery, and the runbook for Sentinel failover all become ancient history.
# redis-py — unchanged
import redis
r = redis.Redis(host="swytch.prod.internal", port=6379, decode_responses=True)
r.set("session:user_42", token)
r.xadd("events", {"kind": "login"})// go-redis — unchanged
import "github.com/redis/go-redis/v9"
rdb := redis.NewClient(&redis.Options{Addr: "swytch.prod.internal:6379"})
rdb.Set(ctx, "session:user_42", token, 0)
rdb.XAdd(ctx, &redis.XAddArgs{Stream: "events", Values: map[string]any{"kind": "login"}})// ioredis — unchanged
import Redis from "ioredis";
const redis = new Redis({ host: "swytch.prod.internal", port: 6379 });
await redis.set("session:user_42", token);
await redis.xadd("events", "*", "kind", "login");# redis-cli — unchanged
redis-cli -h swytch.prod.internal -p 6379
> SET session:user_42 "$TOKEN"
> XADD events * kind loginStrings for the sessions: existing client libraries already speak this. Sorted sets for the leaderboards, with cross-region replication that converges deterministically --no last-writer-wins on the score column.
Streams for the event log, with exactly-once delivery in the data plane. Hashes and keys for the cache, with database-level coherency —every node sees the same writes in the same order.
The cache-aside layer above Postgres becomes the cache-and-broker layer that replaces three line items on the bill.
Deleting infrastructure never felt so good.
Yesterday's "impossible" is today's Swytch base product.
| Property | Redis Cluster | CockroachDB | Spanner | Swytch |
|---|---|---|---|---|
| Leaderless writes | no | no | no | yes |
|
Local writes per region
no cross-region RTT |
replica only | quorum RTT | 2-phase commit | yes |
| Exactly-once delivery in the data plane | no | no | no | yes |
|
Deterministic conflict resolution
not LWW by clock |
LWW | yes | yes | yes |
| Keeps writing during a partition | one side only | minority blocks | minority blocks | both sides |
| No GPS / atomic-clock dependency | yes | yes | needs TrueTime | yes |
|
TLA+ verified
public specs |
no | internal | internal | public |
|
Jepsen tested
reproducible suite |
historical | yes | no public suite | yes |
| Redis 8.4 wire compatible | native | no | no | yes |
|
Self-hosted OSS tier
unlimited nodes |
BSD/RSAL | BSL | managed only | AGPL |
The Light Cone Consistency framework places Swytch’s behavior in a published, verifiable region of the consistency design space.
The TLA+ specifications are public in the repository. The Jepsen suite is reproducible.
Light Cone Consistency: Landers, R. & Kramer, K. · arXiv:2605.09114 [cs.DC] · 9 May 2026 · CC BY 4.0
Free to start. Only a few euros per month to access the world's most reliable data handling platform.
The full leaderless coherent cache. Self-hosted. Forever free.
Durability, cross-region arbitration, managed control plane.
For teams that can’t ship AGPL. Commercial license, dedicated support.
At multi-region scale the total bill runs 3-10x cheaper than Redis Enterprise Active-Active at equivalent semantics.
Short answers to the obvious objections.
Two regions in fifteen minutes. AGPL forever, commercial when you ship.
Not deploying today? Drop your address and we’ll send launch notes and the migration guide.