EP.73 Enhancing WebSocket Performance with Compression

In EP.73, we explore how to enhance WebSocket communication by enabling WebSocket Compression. This technique compresses messages before they are sent through the WebSocket connection, helping reduce payload size, save bandwidth, and improve message delivery speed—especially in systems handling large or repetitive data, such as chat applications or real-time dashboards.

WebSocket Compression is particularly useful for systems with high-frequency communication and many simultaneous connections. It reduces overhead and ensures faster, more efficient data transfer between clients and servers.

Why Use WebSocket Compression?

Enabling WebSocket Compression offers multiple performance benefits:

Reduced payload size: Messages are compressed before transmission, minimizing data usage
Faster data transfer: Compression speeds up the delivery of large or repetitive messages
Lower network/server costs: It reduces resource consumption and helps scale efficiently
Ideal for real-time applications: Works well for chat apps, collaborative tools, and dashboards

How to Enable WebSocket Compression

WebSocket Compression can be enabled on both your application server (Go) and the reverse proxy (e.g., NGINX) to improve overall system efficiency.

1. Enabling Compression in Go WebSocket Server

Here’s how to enable message compression using Go and the gorilla/websocket library:

package main

import (
    "log"
    "net/http"

    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
    EnableCompression: true,
    CheckOrigin: func(r *http.Request) bool {
        return true
    },
}

func handler(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println("Upgrade error:", err)
        return
    }
    defer conn.Close()

    conn.EnableWriteCompression = true

    for {
        msgType, p, err := conn.ReadMessage()
        if err != nil {
            log.Println("Read error:", err)
            break
        }

        err = conn.WriteMessage(msgType, p)
        if err != nil {
            log.Println("Write error:", err)
            break
        }
    }
}

func main() {
    http.HandleFunc("/", handler)
    log.Println("WebSocket Server started on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

🔎 Note: The gorilla/websocket package supports permessage-deflate compression by setting EnableCompression: true on the Upgrader and calling conn.EnableWriteCompression = true.

2. Configuring WebSocket Compression with NGINX

If you’re using NGINX as a reverse proxy in front of your WebSocket server, you can enable gzip compression to improve performance for compatible traffic.

http {
    gzip on;
    gzip_types application/json text/plain;
    gzip_min_length 1024;

    server {
        listen 80;

        location /ws {
            proxy_pass http://localhost:8080;
            proxy_http_version 1.1;
            proxy_set_header Upgrade $http_upgrade;
            proxy_set_header Connection "upgrade";
            proxy_set_header Host $host;
            proxy_cache_bypass $http_upgrade;
        }
    }
}

💡 While NGINX cannot compress raw WebSocket frames directly, it can still compress related HTTP traffic and fallback connections. Use permessage-deflate in your application for direct WebSocket compression.

3. Testing WebSocket Compression

To verify that compression is working properly, try the following:

✅ Send large or repetitive messages and observe how size and latency improve
✅ Compare performance before and after enabling compression using browser DevTools or network monitoring tools
✅ Test with multiple concurrent connections to see how compression affects throughput and system load

Challenge for You!

Try enabling compression in your WebSocket project and benchmark its effect using real-world data. How much bandwidth can you save?

Next EP:

In EP.74, we’ll look into Adding Multilingual Support to WebSocket Chat Systems — enabling users to chat across different languages in real time with automatic detection and formatting 🌐

Read more

🔵 Facebook: Superdev School (Superdev)

📸 Instagram: superdevschool

🎬 TikTok: superdevschool

🌐 Website: www.superdev.school