Performance

Benchmarks

Real-world performance data from three pillars: static file delivery, routing, and mixed workloads.

All benchmarks use autocannon on Kali GNU/Linux Rolling (localhost). XyPriss runs via Bun/XFPM with the XHSC native orchestrator. Baselines (Express, Fastify) run in Node.js single-process mode for fair comparison.

Static Delivery

~13 100

req/s with Cluster ×10 — throughput leader against Express & Fastify.

Routing Avg

~4 569

req/s at 5 000 connections — zero errors, stable under extreme load.

Mixed Workload

837 ms

Average latency at 50 connections (auth + 500 KB file) — lowest among all frameworks.

Pillar 1: Static File Delivery (XStatic)

Comparing Express + serve-static, Fastify + @fastify/static, and XyPriss XStatic go fast path under two cluster configurations.

Throughput (req/s) — Static Files

Concurrent connections

Higher is better

Latence médiane p50 — Static Files

Lower is better (ms)

Key Insight: XStatic dominates without cluster

In single-worker mode, XStatic delivers ~6,500–6,900 req/s — a ×5 to ×8 advantage over Express and Fastify. This gain comes entirely from the Go fast path (sendfile at kernel level), not horizontal scaling.

Pillar 2: Routing (Hello World)

Pure routing with a minimal JSON payload. This is the worst-case scenario for XyPriss — every request crosses the IPC bridge twice (Go → Node.js → Go), making IPC overhead the dominant factor.

Throughput (req/s) — Routing

Concurrent connections

Higher is better (single worker)

Latence moyenne — Routing

Lower is better (ms)

⚠ Error Rate at 1 000 & 5 000 connections

Express drops 61 requests at 1,000 connections — its event loop saturates. XyPriss and Fastify both achieve zero errors at 1,000 and 5,000 connections, thanks to the XHSC goroutine buffer absorbing spikes before they reach Node.js.

Pillar 3: Mixed Workload (Auth + 500 KB File)

Realistic production scenario: authentication middleware (2 ms overhead) followed by a 500 KB binary file transfer. This benchmark validates the architectural advantage of res.sendFile() via XHSC Zero-Copy IPC.

Average Latency — Auth + 500 KB File

Concurrent connections

Lower is better (ms)

Tail Latency p99 — Auth + 500 KB File

Lower is better (ms)

IPC Overhead Is Fully Amortised

In the routing benchmark, XyPriss runs at ~0.48× Fastify due to IPC bridge overhead. In this mixed-workload scenario, the 2 ms auth delay and 500 KB transfer completely amortise the ~15 ms fixed IPC cost. The Zero-Copy path (sendfile at kernel level) then dominates, giving XyPriss the lowest average latency at every load level.

Cross-Pillar Synthesis

Metric	Express	Fastify	XyPriss
Static Throughput (peak)	~1,700 req/s	~2,500 req/s	~13,100 req/s
Routing Throughput (5k conn)	~2,165 req/s	~9,562 req/s	~4,569 req/s
Routing Latency (5k conn)	2 184 ms	712 ms	1 117 ms
Routing Errors (1k–5k)	61+ dropped	0	0
Mixed Avg Latency (50 conn)	976.6 ms	1 370 ms	837.5 ms
Mixed Tail p99 (100 conn)	5 379 ms	8 411 ms	4 182 ms

Takeaways

Zero-Copy Dominates I/O

For static and file-heavy workloads, XHSC's sendfile(2) delegation eliminates Node.js from the data path entirely. Throughput gains of ×5–8 are structural, not accidental.

IPC Cost Is Amortised

On real workloads (auth + file transfer), the ~15 ms fixed IPC bridge cost disappears. XyPriss retains its latency advantage because the Go kernel path is faster than Node.js buffer copies.

Stability Under Pressure

Even on pure routing (the worst case), XyPriss achieves zero errors at 5,000 connections where Express drops requests. The XHSC goroutine queue acts as a natural shock absorber.

Production Recommendations

Enable maxConcurrentTasks: "auto" (XInS) for routing workloads. Enable cluster-workers for throughput multiplication. Use XStatic for all static and file delivery to unlock Zero-Copy.

XHSC Architecture

Understand the native Go engine behind the benchmarks: XHSC, XInS, and IPC bridge internals.