Observed Signal · May 24, 2026 · Benchmark · Source: DEV Community · Impact: 2/5 · Sentiment: Neutral
Benchmark: Node.js vs Bun vs Go HTTP Performance
A developer published a controlled benchmark comparing default HTTP servers in Node.js, Bun and Go across three environments: localhost, an encrypted Tailscale Wi‑Fi mesh, and DigitalOcean cloud droplets. Tests ran each runtime in Docker (single-core and multi-core configurations), serving a simple /json response. Results show Bun leading raw throughput in many cloud multi-core runs (53,446 RPS on 4 cores), Go demonstrating strong single-process, low-latency efficiency (37,617 RPS on 4 cores; optimized raw bytes), and Node.js requiring clustering to approach comparable throughput (31,025 RPS on 4 cores clustered) while showing higher CPU and outlier latency in some scenarios. The author highlights network bottlenecks (local Wi‑Fi adapter) and implementation details (reusePort, Zig event loop, pre-rendered raw bytes) as key factors behind observed differences.
Runtime and network-level performance benchmarks inform backend infrastructure choices and cost/performance trade-offs for high-concurrency services (relevant to backend engineering and ad‑serving stacks), but this is a single-developer benchmark rather than a major platform policy or product release.
Track DigitalOcean Signals & Market Shifts in Real-Time
Polaris7 autonomous intelligence agents track regulatory filings, primary sources, executive changes, and deal flow 24/7. Create your free Explorer workspace to monitor these entities.
Key Takeaways & Evidence Grounding
- Publication date (page metadata): 2026-05-24
- Cloud 4-core benchmark (30s): Bun cluster 53,446 RPS, Go 37,617 RPS, Node.js cluster 31,025 RPS
- Cloud single-core benchmark: Bun 25,444 RPS, Go 13,935 RPS, Node.js 11,705 RPS
- Tailscale/Wi‑Fi (4 cores) throughput/latency snapshot: Bun 12,519 RPS (avg latency 16.49 ms), Go 12,873 RPS (avg 15.69 ms), Node.js 7,954 RPS (avg 26.79 ms) with Node max outlier 864.53 ms
- Tests run inside Docker with resource caps (--cpus, -m), DigitalOcean shared droplets over a 10 Gbps data‑center backplane used for cloud runs; load generated via wrk in an attacker container
Connected Companies & Entities
3 Entities mappedOntology Mapping & Concepts
Related Market Signals & Shifts
Recent verified developments and strategic activity across this market segment.
Bun vs Node.js in 2026: Production Readiness
This technical review compares Bun (tested at v1.2.x) against Node.js 22 LTS on real-world workloads including an Astro + Drizzle + Postgres stack, a Hono API, and a 14-package monorepo. Bun is a single binary runtime built on JavaScriptCore and written in Zig that bundles a package manager, test runner, bundler, and script runner (bun install/test/build/run). Benchmarks show Bun excels at cold package installs, short-script startup time, and synthetic HTTP throughput; real application gains are smaller due to DB drivers and application code dominating hot paths. The article highlights compatibility frictions—native node-gyp modules, subtle process/cluster differences, test-migration edge cases, and workspace tooling assumptions—and recommends using Bun selectively (e.g., for CI installs or greenfield projects) while keeping Node for production on platforms that don’t run Bun. It also notes Node.js 22 has absorbed several developer-experience features previously unique to Bun.
Bun outperforms Node for high-throughput metadata API
An engineer at ViralVidVault benchmarked Bun against Node.js for a read-heavy, stateless batch video metadata endpoint backed by SQLite in WAL mode. The tests (64 concurrent connections, median of five runs) showed Bun delivering roughly 14,800 rps versus Node's ~9,400 rps, with lower median and tail latencies and lower resident memory. Profiling showed SQLite reads were ~2ms, and most latency came from JSON serialization, HTTP framing, and GC in the JavaScript runtime. The author migrated the single hot, read-only metadata endpoint to Bun behind a canary while keeping stateful and write-path services on Node due to native module compatibility, observability, and long-run stability concerns under GDPR obligations.
GoModel Benchmarks AI Gateway Performance
An engineering benchmark comparing four AI gateways — GoModel, LiteLLM, Portkey, and Bifrost — measures runtime and deployment overhead on the request path (latency, throughput, memory, CPU, cold start, and image size). Tests ran reproducibly in Docker on an AWS c7i.large instance against a shared instant mock backend across six workloads and 8,000 requests per workload. Results show GoModel (a small open-source Go gateway) had the lowest overhead (p50 1.8 ms, p99 6.9 ms), smallest memory footprint (37 MB peak), fastest cold start (0.56 s) and highest sustained throughput (4,900 req/s). LiteLLM used ~2.3 GB RAM, had a 25.5 s cold start and sustained 324 req/s. The benchmark harness and reproduction instructions are published in the GoModel repository. Publication date: 2026-06-26.
Track Real-Time Market Signals & Shifts
Set up custom watchlists to receive automated, evidence-grounded executive digests whenever material signals or shifts occur across your tracked landscape.