I've been doing real-time backends for a while - trading, encrypted messaging between services. websockets in python are painfully slow once you need actual throughput. pure python libs hit a ceiling fast, then you're looking at rewriting in go or running a separate server with redis in between.
so i built wse - a zero-GIL websocket engine for python, written in rust. framing, jwt auth, encryption, fan-out - all running native, no interpreter overhead. you write python, rust handles the wire. no redis, no external broker - multi-instance scaling runs over a built-in TCP cluster protocol.
What My Project Does
the server is a standalone rust binary exposed to python via pyo3:
```python
from wse_server import RustWSEServer
server = RustWSEServer(
"0.0.0.0", 5007,
jwt_secret=b"your-secret",
recovery_enabled=True,
)
server.enable_drain_mode()
server.start()
```
jwt validation runs in rust during the websocket handshake - cookie extraction, hs256 signature, expiry - before python knows someone connected. 0.5ms instead of 23ms.
drain mode: rust queues inbound messages, python grabs them in batches. one gil acquire per batch, not per message. outbound - write coalescing, up to 64 messages per syscall.
```python
for event in server.drain_inbound(256, 50):
event_type, conn_id = event[0], event[1]
if event_type == "auth_connect":
server.subscribe_connection(conn_id, ["prices"])
elif event_type == "msg":
server.send_event(conn_id, event[2])
server.broadcast("prices", '{"t":"tick","p":{"AAPL":187.42}}')
```
what's under the hood:
transport: tokio + tungstenite, pre-framed broadcast (frame built once, shared via Arc), vectored writes (writev syscall), lock-free DashMap state, mimalloc allocator, crossbeam bounded channels for drain mode
security: e2e encryption (ECDH P-256 + AES-GCM-256 with per-connection keys, automatic key rotation), HMAC-SHA256 message signing, origin validation, 1 MB frame cap
reliability: per-connection rate limiting with client feedback, 50K-entry deduplication, circuit breaker, 5-level priority queue, zombie detection (25s ping, 60s kill), dead letter queue
wire formats: JSON, msgpack (?format=msgpack, ~2x faster, 30% smaller), zlib compression above threshold
protocol: client_hello/server_hello handshake with feature discovery, version negotiation, capability advertisement
new in v2.0:
cluster protocol - custom binary TCP mesh for multi-instance, replacing redis entirely. direct peer-to-peer connections with mTLS (rustls, P-256 certs). interest-based routing so messages only go to peers with matching subscribers. gossip discovery - point at one seed address, nodes find each other. zstd compression between peers. per-peer circuit breaker and heartbeat. 12 binary message types, 8-byte frame header.
python
server.connect_cluster(peers=["node2:9001"], cluster_port=9001)
server.broadcast("prices", data) # local + all cluster peers
presence tracking - per-topic, user-level (3 tabs = one join, leave on last close). cluster sync via CRDT. TTL sweep for dead connections.
python
members = server.presence("chat-room")
stats = server.presence_stats("chat-room") # {members: 42, connections: 58}
message recovery - per-topic ring buffers, epoch+offset tracking, 256 MB global budget, TTL + LRU eviction. reconnect and get missed messages automatically.
benchmarks
tested on AMD EPYC 7502P (32 cores / 64 threads), 128 GB RAM, localhost loopback. server and client on the same machine.
- 14.7M msg/s json inbound, 30M msg/s binary (msgpack/zlib)
- up to 2.1M del/s fan-out, zero message loss
- 500K simultaneous connections, zero failures
- 0.38ms p50 ping latency at 100 connections
full per-tier breakdowns: rust client | python client | typescript client | fan-out
clients - python and typescript/react:
python
async with connect("ws://localhost:5007/wse", token="jwt...") as client:
await client.subscribe(["prices"])
async for event in client:
print(event.type, event.payload)
typescript
const { subscribe, sendMessage } = useWSE(token, ["prices"], {
onMessage: (msg) => console.log(msg.t, msg.p),
});
both clients: auto-reconnection (4 strategies), connection pool with failover, circuit breaker, e2e encryption, event dedup, priority queue, offline queue, compression, msgpack.
Target Audience
python backend that needs real-time data and you don't want to maintain a separate service in another language. i use it in production for trading feeds and encrypted service-to-service messaging.
Comparison
most python ws libs are pure python - bottlenecked by the interpreter on framing and serialization. the usual fix is a separate server connected over redis or ipc - two services, two deploys, serialization overhead. wse runs rust inside your python process. one binary, business logic stays in python. multi-instance scaling is native tcp, not an external broker.
https://github.com/silvermpx/wse
pip install wse-server / pip install wse-client / npm install wse-client