Skip to main content
Sockudo Hero Light

​
What is Sockudo?

Sockudo is a blazingly fast WebSocket server built in Rust that implements the Pusher protocol. It’s designed to handle 100,000+ concurrent connections with low latency and high throughput, making it perfect for real-time applications like live dashboards, chat systems, gaming, and financial trading platforms.

​
Why Sockudo?

Sockudo is a drop-in replacement for Pusher services, allowing you to host your own real-time infrastructure without vendor lock-in. Built from the ground up in Rust with Tokio’s async runtime, it delivers exceptional performance and reliability.

100K+ Connections

Handle massive scale with minimal resources. Optimized for high concurrency with async Rust and efficient memory management.

Pusher Compatible

Drop-in replacement for Pusher. Use existing client SDKs (pusher-js, pusher-swift, etc.) with zero code changes.

Horizontal Scaling

Scale across multiple nodes with Redis, Redis Cluster, or NATS adapters. Built-in support for multi-region deployments.

Delta Compression

Save 60-90% bandwidth with delta compression using Fossil or Xdelta3 algorithms. Perfect for high-frequency updates.

Tag Filtering

Server-side event filtering by tags reduces client bandwidth by 60-90%. Subscribe only to events that matter.

Production Ready

Rate limiting, SSL/TLS, Prometheus metrics, graceful shutdown, and comprehensive logging out of the box.

​
Key Features

​
Performance & Scalability

  • High Performance: Built with Rust and Tokio for maximum throughput and minimal latency
  • 100K+ Concurrent Connections: Tested and optimized for massive scale
  • Horizontal Scaling: Redis, Redis Cluster, and NATS adapters for distributed deployments
  • Async Cleanup: Non-blocking disconnect handling prevents performance degradation
  • Native WebSocket Engine: Custom sockudo_ws engine with advanced runtime tuning

​
Bandwidth Optimization

Delta compression and tag filtering can reduce bandwidth usage by 60-90% in high-volume scenarios.
  • Delta Compression: Fossil and Xdelta3 (VCDIFF) algorithms with per-channel controls
  • Conflation Keys: Isolate delta state per logical stream (e.g., by asset, symbol, or user ID)
  • Tag Filtering: Server-side publication filtering with zero-allocation evaluation
  • Cluster Coordination: Synchronized full message intervals across nodes (optional)

​
Developer Experience

  • Pusher Protocol: Full compatibility with Pusher client libraries
  • Multiple Backends: Choose from Redis, NATS, MySQL, PostgreSQL, DynamoDB, and more
  • Feature Flags: Compile only what you need for faster builds (30-50% faster in development)
  • Rich Metrics: Prometheus integration for monitoring and alerting
  • Docker Ready: Production-ready containers with docker-compose examples

​
Sockudo vs Pusher

FeatureSockudoPusher
ProtocolPusher-compatiblePusher
HostingSelf-hostedCloud-only
PricingFree (infrastructure costs only)Pay per connection
Performance100K+ connections per nodeLimited by plan
Delta Compression✅ Fossil & Xdelta3❌
Tag Filtering✅ Server-side filtering❌
ScalingRedis, Redis Cluster, NATSManaged
CustomizationFull controlLimited

​
Use Cases

Stream real-time metrics, analytics, and KPIs to dashboards. Delta compression reduces bandwidth for high-frequency numeric updates.
Deliver market data, order book updates, and trade executions with minimal latency. Tag filtering lets clients subscribe to specific symbols.
Synchronize game state across players with presence channels. Handle 100K+ concurrent players on a single cluster.
Build scalable chat applications with private and presence channels. Support thousands of concurrent conversations.
Broadcast live scores, play-by-play updates, and statistics. Tag filtering allows users to follow specific events or teams.
Stream telemetry data from thousands of devices. Delta compression minimizes bandwidth costs for sensor updates.

​
Architecture

Sockudo uses a modular architecture with pluggable backends: 
┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   Load Balancer │────│   Sockudo Node  │────│   Redis Cluster │
│    (Nginx)      │    │    (Rust/Tokio) │    │  (State Store)  │
└─────────────────┘    └─────────────────┘    └─────────────────┘
         │                       │                       │
         │              ┌─────────────────┐             │
         └──────────────│   Sockudo Node  │─────────────┘
                        │    (Rust/Tokio) │
                        └─────────────────┘

​
Core Components

  • Adapter: Manages connections and broadcasts across nodes (Local, Redis, Redis Cluster, NATS)
  • App Manager: Stores application credentials (Memory, MySQL, PostgreSQL, DynamoDB)
  • Cache: Speeds up repeated lookups (Memory, Redis, Redis Cluster)
  • Queue: Background job processing (Memory, Redis, Redis Cluster, SQS)
  • Rate Limiter: Protects against abuse (Memory, Redis, Redis Cluster)
  • Metrics: Prometheus-compatible metrics export

​
Next Steps

Quickstart

Get Sockudo running in 5 minutes with Docker

Installation

Detailed installation options and feature flags

Configuration

Configure Sockudo for your environment

API Reference

Complete API documentation

​
Community & Support

GitHub

Star the repo and contribute

Discord

Join our community

X (Twitter)

Follow for updates

Build docs developers (and LLMs) love

Get started for freeTalk to us