whatisgithub

What is websocket-stt-bench?

cezarc1/websocket-stt-bench — explained in plain English

Analysis updated 2026-05-18

1RustAudience · developerComplexity · 4/5Setup · hard

In one sentence

A benchmark comparing how many concurrent WebSocket audio streaming sessions different languages and runtimes handle per CPU.

Mindmap

mindmap
  root((websocket-stt-bench))
    What it does
      Streams audio over WebSocket
      Simulates speech to text gateway
      Compares runtimes per vCPU
    Tech stack
      Rust
      C++
      Python
      Go
      Java
    Use cases
      Choosing a runtime for realtime audio
      Comparing async vs thread models
      Benchmarking WebSocket throughput
    Audience
      Backend developers
      Performance engineers
      Researchers

Code map

Detail Auto

An interactive map of this repo's files and how they connect — its source is parsed live in your browser. Click Visualize to build it.

filefunction / class

What do people build with it?

USE CASE 1

Compare which language and runtime handles the most concurrent WebSocket audio sessions per CPU.

USE CASE 2

Use the benchmark harness as a template to test your own streaming service under a similar load.

USE CASE 3

Read the per-language BENCHMARK.md files to learn tuning tricks for each runtime's WebSocket stack.

What is it built with?

RustC++PythonGoJavaElixirScalaOCaml

How does it compare?

cezarc1/websocket-stt-benchabc3dz/mixxxabyo-software/ferro-stash
Stars111
LanguageRustRustRust
Setup difficultyhardmoderatemoderate
Complexity4/52/54/5
Audiencedevelopergeneralops devops

Figures from each repo's GitHub metadata at analysis time.

How do you get it running?

Difficulty · hard Time to first run · 1h+

Requires a Kubernetes cluster (k3s) and building multiple language runtimes to reproduce the full benchmark.

So what is it?

websocket-stt-bench is a benchmark project that measures how many concurrent WebSocket audio streaming sessions different programming languages and runtimes can handle on a single virtual CPU. It simulates a speech to text gateway: clients stream small chunks of raw audio over a WebSocket connection, and each server implementation buffers that audio, periodically sends it to a shared Rust based inference simulator, and returns partial transcript results back to the client as JSON messages. The project builds the same benchmark server in many different languages and frameworks so they can be compared side by side, including C++ with uWebSockets, Python with FastAPI and uvloop, Elixir with Phoenix, Rust with both async Axum and a lower level two thread version without an async runtime, TypeScript on Bun, Go, Java with Helidon virtual threads, Scala with the Pekko actor framework, and two flavors of OCaml. Each implementation is tested against the same service level target, and results are reported as the highest number of concurrent sessions that still met that target at one and two virtual CPUs. According to the results in the README, a plain Rust build using two threads and no async runtime handled the most sessions per CPU, narrowly ahead of the C++ implementation, while async Rust with Axum offered the best balance between how much code it took to write and how many sessions it could handle. Java, Bun, and Go form a middle tier, and Elixir and Scala score lower on a single CPU but scale up well when given a second one. The author notes using AI coding agents to help write several of the language implementations, with varying levels of ease depending on the language. The benchmarks were run on a single machine with an Intel Core i9 processor, Ubuntu, and a small Kubernetes cluster, and detailed run notes for each language live in their own benchmark documents inside the repository. The project is written primarily in Rust.

Copy-paste prompts

Prompt 1
Summarize how the no-async-runtime Rust build in this benchmark beat the async Axum version.
Prompt 2
Explain why actor-model runtimes like Elixir and Scala scale well from 1 to 2 vCPUs in this benchmark.
Prompt 3
Help me adapt this benchmark's WebSocket protocol to test my own streaming server.
Prompt 4
Compare the LOC versus sessions-per-vCPU tradeoff across the languages in this benchmark.

Frequently asked questions

What is websocket-stt-bench?

A benchmark comparing how many concurrent WebSocket audio streaming sessions different languages and runtimes handle per CPU.

What language is websocket-stt-bench written in?

Mainly Rust. The stack also includes Rust, C++, Python.

How hard is websocket-stt-bench to set up?

Setup difficulty is rated hard, with roughly 1h+ to a first successful run.

Who is websocket-stt-bench for?

Mainly developer.

Open on GitHub → Ask about another repo

This repo across BitVibe Labs

Verify against the repo before relying on details.