Pulse

The world's fastest realtime communication engine for web and edge applications.

Pulse is a high-performance, transport-agnostic pub/sub messaging system built in Rust. It's designed for applications that need sub-millisecond latency and massive scale.

Features

• Blazing Fast: Lock-free data structures, zero-copy message passing
• Transport Agnostic: WebSocket today, WebTransport tomorrow
• Protocol Efficient: Binary MessagePack encoding
• Developer Friendly: Simple pub/sub API
• Observable: Built-in Prometheus metrics
• Production Ready: Comprehensive error handling and logging

Quick Start

Installation

# From crates.io
cargo install pulse-server

# From source
git clone https://github.com/tenvisio/pulse
cd pulse
cargo build --release

Run the Server

# With defaults (localhost:8080)
pulse

# With custom port
PULSE_PORT=9000 pulse

# With config file
pulse --config pulse.toml

Connect a Client

Messages use MessagePack encoding with a 4-byte length prefix. Here's the message structure:

// Subscribe to a channel
{ type: 'subscribe', id: 1, channel: 'chat:lobby' }

// Publish a message
{ type: 'publish', channel: 'chat:lobby', payload: /* msgpack bytes */ }

// Unsubscribe
{ type: 'unsubscribe', id: 2, channel: 'chat:lobby' }

Note: The wire format requires a 4-byte big-endian length prefix before each MessagePack frame. See examples/web-client/ for a complete working browser implementation, or wait for the upcoming TypeScript SDK.

Architecture

┌────────────────────────────────────────────────────────────┐
│                      pulse-server                          │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐ │
│  │   Config    │  │   Metrics   │  │      Handlers       │ │
│  └─────────────┘  └─────────────┘  └─────────────────────┘ │
└────────────────────────────────────────────────────────────┘
                            │
                            ▼
┌────────────────────────────────────────────────────────────┐
│                       pulse-core                           │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐ │
│  │   Router    │  │   Channel   │  │      Presence       │ │
│  └─────────────┘  └─────────────┘  └─────────────────────┘ │
└────────────────────────────────────────────────────────────┘
                            │
                            ▼
┌────────────────────────────────────────────────────────────┐
│                    pulse-transport                         │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐ │
│  │  WebSocket  │  │ WebTransport│  │     Fallback        │ │
│  └─────────────┘  └─────────────┘  └─────────────────────┘ │
└────────────────────────────────────────────────────────────┘
                            │
                            ▼
┌────────────────────────────────────────────────────────────┐
│                     pulse-protocol                         │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐ │
│  │   Frames    │  │    Codec    │  │      Version        │ │
│  └─────────────┘  └─────────────┘  └─────────────────────┘ │
└────────────────────────────────────────────────────────────┘

Crates

Configuration

Create a pulse.toml file:

[server]
host = "0.0.0.0"
port = 8080

[transport]
websocket = true
webtransport = false  # Experimental

[limits]
max_connections = 100000
max_channels = 10000
max_subscriptions_per_connection = 100
max_message_size = 65536  # 64 KB

[heartbeat]
interval_ms = 30000
timeout_ms = 60000

[metrics]
enabled = true
port = 9090

Or use environment variables:

export PULSE_HOST=0.0.0.0
export PULSE_PORT=8080
export PULSE_LIMITS_MAX_CONNECTIONS=100000

Protocol

Pulse uses a binary protocol based on MessagePack. See the full Protocol Specification.

Frame Types

Benchmarks

Run benchmarks:

# Run micro-benchmarks (Criterion)
cargo bench -p pulse-bench

# Run specific benchmark file
cargo bench -p pulse-bench --bench throughput
cargo bench -p pulse-bench --bench latency

# Run end-to-end throughput test (requires server running)
# Terminal 1: Start the server
cargo run --release -p pulse-server

# Terminal 2: Run e2e benchmark with 16 clients (default)
cargo run --release -p pulse-bench --bin e2e_throughput

# Or with custom client count
cargo run --release -p pulse-bench --bin e2e_throughput -- 64

Results

Fanout Performance

Note: Publish time is constant regardless of subscriber count thanks to efficient broadcast channels.

Benchmarks run on Apple M2 MacBook Air, results will vary.

Comparison

Roadmap

• Core pub/sub router
• WebSocket transport
• Presence tracking
• Prometheus metrics
• Docker images
• WebTransport support
• Redis adapter for clustering
• Message persistence/replay
• TypeScript client SDK
• Authentication hooks
• Rate limiting

Contributing

We welcome contributions! Please see our Contributing Guide.

# Setup
git clone https://github.com/tenvisio/pulse
cd pulse
cargo build

# Run tests
cargo test

# Run clippy
cargo clippy -- -D warnings

# Format code
cargo fmt

License

Pulse is dual-licensed under the MIT License and Apache License 2.0.

Acknowledgments

Built with:

• Tokio - Async runtime
• Axum - Web framework
• DashMap - Concurrent hashmap
• MessagePack - Efficient serialization

_{Built by tenvisio}