Relay vs Laravel Reverb: A Real Performance Benchmark

Jayden Robbins — Mon, 13 Apr 2026 16:24:00 +0000

We built Relay because we believed a WebSocket server written in Go would handle real-world connection loads more efficiently than one running in PHP. We wanted to find out by how much. So we ran a real benchmark. Here's exactly what we did, what we found, and what it means.

Test Setup

Benchmark runner: Hetzner CAX11 (4GB RAM, ARM64, Ubuntu 24.04)
Relay server: Hetzner CX23 — separate machine, tested over the network
Reverb server: Running locally on the benchmark box (loopback — an advantage for Reverb)
Load testing tool: k6 v0.55.0
Test: Ramp from 0 to 1,000 concurrent WebSocket connections over 5 minutes, hold at 1,000 for 60 seconds

Results at 1,000 Concurrent Connections

Metric	Relay (Go)	Laravel Reverb (PHP)
Process memory	~38 MB	~63 MB
CPU at peak	~18%	~95%
Server load average	0.62	2.95
Total server RAM	700 MB	962 MB

What the Numbers Mean

Reverb hit 95% CPU. Relay hit 18%. That means Reverb is near its ceiling at 1,000 connections on a $5 server. Relay is barely warming up.

The headroom difference is what matters in production. When traffic spikes, Relay absorbs it. Reverb starts dropping connections.

Go's goroutine model is the reason. Each WebSocket connection in Relay is handled by a goroutine — lightweight, cheap to schedule, independently managed. PHP's event loop works, but it pays a higher price per connection.

The Honest Caveat

Reverb ran on loopback while Relay ran over the network — a latency advantage for Reverb. Despite this, Relay won on every resource metric.

Reverb is a well-built product with first-party Laravel support. If you're running a pure Laravel monolith and want Taylor Otwell's name behind your WebSocket server, Reverb is a solid choice.

When to Choose Relay

Polyglot stack (Next.js, Rails, Django, Node — not just Laravel)
You want a managed cloud option without vendor lock-in
You want a live Channel Inspector in your dashboard
Self-host free forever, optionally move to managed hosting with zero code changes
Better resource efficiency at scale

Try It

Relay is open source (MIT) and free to self-host forever:
👉 github.com/DarkNautica/Relay

Relay Cloud is the optional managed tier with a free hobby plan:
👉 relaycloud.dev

Laravel package:

composer require darknautica/relay-cloud-laravel

Originally published at relaycloud.dev/blog/relay-vs-reverb-benchmark

I built a free self-hosted alternative to Pusher

Jayden Robbins — Sun, 12 Apr 2026 17:44:18 +0000

Every modern web app eventually needs real-time features. Live
notifications, chat, presence indicators, collaborative editing.
The moment you need it, every tutorial points you to Pusher.

Pusher is great. It works, it's well documented, and the
developer experience is solid. But the pricing hits hard once
you have real traffic. 100 concurrent connections on the free
tier. $49/month for 500. The bill scales faster than your app.

The underlying technology — WebSockets — is open, well
understood, and has been around for years. There was no good
reason a polished self-hosted alternative didn't exist.

So I built one.

Introducing Relay

Relay is an open source, self-hostable WebSocket server written
in Go. It gives you everything Pusher does at the cost of
running a small server process on infrastructure you already own.

The key design decision was full Pusher protocol compatibility.
If you are already using Pusher, you can switch to Relay by
changing one environment variable. No SDK changes, no refactoring,
no migration script. Just point your app at your Relay server
instead.

Getting started in 30 seconds

docker run -d -p 6001:6001 \
  -e RELAY_APP_KEY=my-key \
  -e RELAY_APP_SECRET=my-secret \
  darknautica/relay:latest

That is the entire server setup. It starts on port 6001,
serves a live dashboard at /dashboard, and is ready to
accept WebSocket connections.

Connecting from JavaScript

import Relay from '@relayhq/relay-js'

const relay = new Relay('my-key', {
  host: 'your-server.com',
  port: 6001,
})

const channel = relay.subscribe('notifications')

channel.bind('new-notification', (data) => {
  console.log(data.message)
})

Publishing from Laravel

composer require relayhq/relay-php

// config/broadcasting.php
'default' => 'relay',
'connections' => [
    'relay' => [
        'driver'  => 'relay',
        'host'    => env('RELAY_HOST', '127.0.0.1'),
        'port'    => env('RELAY_PORT', 6001),
        'key'     => env('RELAY_APP_KEY'),
        'secret'  => env('RELAY_APP_SECRET'),
    ],
],

Then your existing broadcast events just work.

broadcast(new OrderShipped($order));

What it supports

Public, private, and presence channels
HMAC authentication for private and presence channels
HTTP publish API for backend event publishing
Built-in web dashboard with live connection stats and event log
Channel history and replay for clients that reconnect
Webhooks with HMAC-signed payloads
Multi-app support via apps.json
Rate limiting and graceful shutdown
Official SDKs for Laravel, Node.js, Rails, and Django
Single binary — no runtime, no JVM, no Node required

The comparison that matters

Pusher free tier gives you 100 concurrent connections and
200k messages per day. Relay gives you unlimited everything
for the cost of a $5/month VPS.

For a startup with 300 concurrent users, that is the
difference between $0 and $49/month. Over a year that is
$588 — more than the server costs for the whole year.

Try it

The project is MIT licensed and lives on GitHub. Pre-built
binaries for Windows, Mac, and Linux are available on the
releases page. A Docker image is published to Docker Hub.

GitHub: https://github.com/DarkNautica/Relay
Docs: https://darknautica.github.io/Relay
Docker: darknautica/relay

Would love feedback from anyone who has dealt with the
Pusher pricing wall. Happy to answer questions about the
Go architecture or the protocol implementation.

Forem: Jayden Robbins