Benchmarks
NextRush v3 performance dashboard — head-to-head HTTP throughput vs Fastify, Hono, Koa, Express, and a raw Node.js baseline. Interactive charts, heatmap, scenario explorer, and reproducible methodology.
NextRush is built for production throughput without sacrificing safety. This page is a performance dashboard for the latest parity-validated suite run — not a wall of anonymous bar charts. Every figure comes from apps/benchmark and the same results.json you can regenerate yourself.
Performance
Designed for production throughput.
NextRush v3 ranks #3 overall among popular Node.js frameworks — consistently ~85–92% of a raw Node baseline on like-for-like scenarios, with Fastify ahead and Hono behind.
Timed runs
1,404
Frameworks
6
Scenarios
13
Headline rank
#3
Run 2026-07-31T18-15-15 · wrk 4.2.0 · Node v26.5.1 · Intel Core i5-8300H · 8 logical cores · standard · 6 runs · 30s · pin 2–7
Compare frameworks
Overall ranking
Like-for-like scenarios only — 9 scenarios × 2 concurrency levels × 6 frameworks = 108 points. A win is worth 6 points, last place 1. Ties inside noise split points.
- 118wRaw Node.jsbaseline105.5/108
- 25wFastify90.5/108
- 30wNextRush v3target68.1/108
- 40wHono60.1/108
- 50wKoa34/108
- 60wExpress20/108
Hello World @ 256c
Vertical column chart — pure framework overhead. The everyday “how fast is the shell?” number.
req/s · higher is better
Same data, ranked
Horizontal leaderboard view of the same cell. Rank badges + % of leader.
Scenario heatmap
One glance across every like-for-like scenario. Each cell is % of the fastest framework in that row.
| Scenario | Raw | NextRush | Fastify | Hono | Koa | Express |
|---|---|---|---|---|---|---|
| Hello World | 100% | 88.3% | 92.1% | 87.5% | 69.8% | 63.4% |
| JSON Serialization | 100% | 90.6% | 97.4% | 85.6% | 70.3% | 65.5% |
| Large JSON | 100% | 91.7% | 96.3% | 86% | 76.2% | 68.9% |
| Send Object | 100% | 89.9% | 89% | 84.5% | 68.5% | 61.1% |
| Route Parameters | 100% | 85.7% | 91.3% | 82.9% | 69% | 62% |
| Deep Route | 100% | 87.7% | 94.2% | 87.3% | 69.9% | 65.3% |
| Query Strings | 100% | 88.7% | 95.2% | 84.7% | 70.3% | 66.2% |
| POST JSON | 100% | 75.3% | 80.7% | 78.5% | 63.5% | 61.4% |
| Empty Response | 100% | 79.8% | 88.8% | 79.7% | 67.1% | 73% |
Cell = % of the fastest framework in that scenario @ 256 connections. Green is near the leader; amber/rose trails.
Scenario explorer
Pick a scenario to see purpose, story metrics, charts, and latency.
Hello World
Minimal JSON response — pure framework overhead.
NextRush
31,343
RPS @ 256c
vs baseline
88.3%
of raw Node
vs Fastify
-4.2%
relative
Latency p50
7.98ms
p99 10.09ms
Why it matters. Shows how much cost the framework adds before any real work. In this run: NextRush sits at 88% of raw Node — mid-pack with Fastify and Hono inside noise. vs Hono: +0.9%.
req/s · higher is better
| Framework | RPS | CV% | p50 | p99 |
|---|---|---|---|---|
| Raw Node.js | 35,503 | 1.59 | 6.86ms | 10.95ms |
| Fastify | 32,703 | 4.92 | 7.23ms | 11.75ms |
| NextRush v3 | 31,343 | 2.51 | 7.98ms | 10.09ms |
| Hono | 31,073 | 2.15 | 8.16ms | 8.68ms |
| Koa | 24,779 | 2.16 | 10.22ms | 11.12ms |
| Express | 22,508 | 2.91 | 11.17ms | 12.42ms |
Concurrency scaling
Hello World RPS at 1 · 64 · 256 connections. Line color matches the framework legend.
Hello World RPS across concurrency. All frameworks plateau similarly from 64→256 — no scaling collapse under load in this run.
What the numbers mean
Takeaways a reader should remember — not just the raw RPS table.
Serialization is a strength
Large JSON (91.7%) and Send Object (89.9%) sit closest to the raw Node baseline — low framework tax when payload work dominates.
Routing stays competitive
Route params and deep routes hold ~86–88% of baseline and track Fastify within a few points; Hono trails slightly on most routing cells.
POST JSON is the main gap
75% of baseline. Body parsers are not equivalent: safety checks (depth limits, prototype poisoning) cost RPS. Raw Node does the least defensive work here.
Noise ≠ ranking
18 adjacent orderings fall inside combined stddev (including several NextRush ↔ Fastify / Hono pairs). Those are scored as ties — do not cite them as leads.
Stable under concurrency
Scaling from 64→256 connections plateaus cleanly for every framework. No collapse under the headline throughput regime.
Idiomatic ≠ like-for-like
Middleware, error handling, and static file use each framework’s own mechanism. Shown for completeness; excluded from the 108-point headline.
Trust these numbers
Mechanical fairness guarantees from the parity-validated suite. Full detail in Methodology below.
- CPU pinned (server 2–7 · client 0–1)
- Framework order rotated
- 6 runs × sample stddev + CV%
- Parity-validated identical payloads
- Process-isolated wrk (not event-loop shared)
- Warmup before every timed cell
- Gaps inside noise scored as ties
- Deviations from stock defaults disclosed
How to read the scoreboard
The headline number is not “wins every RPS race.” It is a points total over like-for-like work:
| Rule | Detail |
|---|---|
| Scored scenarios | 9 like-for-like scenarios (byte-identical responses across frameworks) |
| Concurrency | Ranked at 64c and 256c (1c is a latency probe, not headline) |
| Points | 6 frameworks → win = 6 pts, last = 1 pt per cell |
| Max | 9 × 2 × 6 = 108 points |
| Excluded | middleware-stack, error-handling, static-file (idiomatic mechanisms) · large-post (not measured at headline concurrency) |
Raw Node.js is the zero-framework baseline. It winning most cells is expected — it is the yardstick, not a product competitor.
| Rank | Framework | Score | Scenario wins | Role |
|---|---|---|---|---|
| 🥇 | Raw Node.js | 105.5 / 108 | 18 | baseline |
| 🥈 | Fastify | 90.5 / 108 | 5 | comparison |
| 🥉 | NextRush v3 | 68.1 / 108 | 0 | target |
| 4 | Hono | 60.1 / 108 | 0 | comparison |
| 5 | Koa | 34.0 / 108 | 0 | comparison |
| 6 | Express | 20.0 / 108 | 0 | comparison |
Story in one paragraph
NextRush sits consistently mid-pack of modern frameworks: above Hono/Koa/Express, behind Fastify and the raw baseline. On serialization-heavy routes it reaches ~90–92% of baseline. The main relative gap is POST JSON (75%), where parsers do unequal safety work. Several NextRush ↔ Fastify / Hono orderings fall inside measurement noise and are scored as ties — treat those as “too close to call,” not marketing wins.
Summary table @ 256 connections
Requests per second (mean of 6 runs). Bold = fastest in row. † = idiomatic (not in headline score).
| Scenario | Raw Node | NextRush v3 | Fastify | Hono | Koa | Express |
|---|---|---|---|---|---|---|
| Hello World | 35,503 | 31,343 | 32,703 | 31,073 | 24,779 | 22,508 |
| JSON Serialization | 34,466 | 31,242 | 33,570 | 29,515 | 24,224 | 22,567 |
| Route Parameters | 33,672 | 28,847 | 30,743 | 27,911 | 23,217 | 20,889 |
| Query Strings | 27,786 | 24,652 | 26,452 | 23,542 | 19,530 | 18,395 |
| POST JSON | 25,420 | 19,144 | 20,508 | 19,953 | 16,132 | 15,617 |
| Deep Route | 32,669 | 28,637 | 30,776 | 28,521 | 22,844 | 21,332 |
| Large JSON | 22,589 | 20,717 | 21,748 | 19,416 | 17,209 | 15,558 |
| Empty Response | 44,818 | 35,778 | 39,782 | 35,714 | 30,077 | 32,730 |
| Send Object | 35,329 | 31,751 | 31,456 | 29,849 | 24,201 | 21,570 |
| Middleware Stack † | 30,749 | 24,188 | 30,527 | 24,273 | 21,964 | 20,180 |
| Error Handling † | 24,971 | 19,409 | 21,534 | 20,457 | 16,763 | 15,474 |
| Static File † | 14,759 | 9,238 | 11,000 | 7,922 | 6,556 | 10,996 |
NextRush vs baseline (like-for-like only): Hello 88% · JSON 91% · Params 86% · Query 89% · POST 75% · Deep 88% · Large JSON 92% · Empty 80% · Send Object 90%.
Measurement environment
| Property | Value |
|---|---|
| Run ID | 2026-07-31T18-15-15 |
| CPU | Intel Core i5-8300H @ 2.30GHz (8 logical cores) |
| Platform | linux x64 · kernel 7.1.5 |
| Node.js | v26.5.1 |
| Memory | 15.46 GB total |
| Load tool | wrk 4.2.0 (process-isolated) |
| Duration | 30 s per cell |
| Connections | 1 · 64 · 256 |
| Runs / config | 6 (mean ± sample stddev + CV%) |
| CPU pinning | server cores 2–7 · client cores 0–1 |
| Order | framework order rotated |
| Timed cells | 1,404 × 30s |
Framework versions (recorded at run time)
| Server | Version | Role |
|---|---|---|
| Raw Node.js | Node v26.5.1 | baseline |
| NextRush v3 | 4.0.0-beta.0 (workspace) | target |
| Fastify | 5.10.0 | comparison |
| Hono | 4.12.30 | comparison |
| Koa | 3.2.1 | comparison |
| Express | 5.2.1 | comparison |
Methodology
Parity gate first
pnpm bench:validate boots every server and asserts byte-identical bodies, statuses, and headers for like-for-like scenarios. A mismatch aborts the run before any timing.
Process isolation
wrk runs as a separate C process. It does not share the server’s Node event loop (unlike in-process autocannon).
Warmup + cooldown
Framework-level and per-scenario warmup so JIT paths are hot. Cooldown between frameworks; pause between cells.
Noise control
CPU pinning, rotated framework order, no HTTP pipelining, multi-run statistics. Adjacent rankings whose gap is smaller than combined stddev are ties, not leads.
Disclosed deviations
Stock defaults that would break parity (e.g. Express etag hashing, Fastify response schemas) are adjusted and listed in the report with who they help or hurt.
Read absolute RPS carefully
Load runs over loopback — client and server share one machine. Absolute RPS reflects the whole box, not a framework in isolation. Use relative rankings on identical hardware. Different machines (and dirty working trees) produce different absolute numbers. Body/query parsers also do unequal safety work; a parse scenario rewards the least-defensive parser.
Known work asymmetries called out in the report:
- query-string — NextRush decodes pairs and enforces limits + prototype-key rejection; raw Node uses bare
URLSearchParams. - post-json — Fastify uses secure-json-parse by default; NextRush adds nesting-depth checks; raw Node uses bare
JSON.parse. - static-file — raw Node matches one literal path with no traversal-safe resolver (mechanism comparison).
Run it yourself
cd apps/benchmark
pnpm install
# 1. Confirm fairness — identical bodies/headers or the run aborts
pnpm bench:validate
# 2. Publishable multi-framework compare (CPU-pinned)
node scripts/run.js --compare --profile standard --runs 6 --pin 2-7 --client-pin 0-1
# 3. Generate report + tables from results.json
pnpm report| Profile | Duration | Connections | Runs | Publishable? |
|---|---|---|---|---|
quick | 10s | 64, 128 | 1 | No |
standard | 30s | 1, 64, 256 | 3+ | Yes (when clean + multi-run) |
full | 60s | 1, 64, 256, 512 | 5 | Yes |
Full methodology, fairness guarantees, and wall-clock estimates live in apps/benchmark/README.md. Latest machine report: apps/benchmark/results/latest/REPORT.md.
Related
- Performance tuning — middleware order, hot-path hygiene, runtime flags
- Framework comparison — code patterns and architecture (not RPS)
- Scaling — horizontal scaling and deployment topology