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 tenvis-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 tenvis-pulse-bench

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

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

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

# Or with custom client count
cargo run --release -p tenvis-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}

lib.rs:

pulse-protocol

Wire protocol definitions for the Pulse realtime communication engine.

This crate defines the binary protocol used for communication between Pulse clients and servers, including frame types, codecs, and versioning.

Frame Types

• Subscribe / Unsubscribe - Channel membership
• Publish - Send messages to channels
• Presence - Track online users
• Ack / Error - Acknowledgments and errors

Example

use pulse_protocol::{Frame, codec};

// Create a publish frame using the helper method
let frame = Frame::publish("chat:lobby", b"Hello, world!".to_vec());

// Encode and decode
let encoded = codec::encode(&frame).unwrap();
let decoded = codec::decode(&encoded).unwrap();