Benchmarks

@dunx/http against raw Bun.serve, Elysia, Hono, Fastify, Express and bare node:http. The number worth having is the gap to raw Bun.serve: dunx is a layer on that exact API, so the gap is dunx's own overhead. Rows are ordered by measured throughput, losses included, and request logging gets its own row rather than being folded into the framework's number.

AMD Ryzen 9 5950X 16-Core Processor, 32 logical cores, 62.7 GiB RAM · linux 7.0.0-31-generic x64 · bun 1.4.2 · node v24.21.0

64 connections · 3s warmup · 5 x 5s measured (median) · 7 startup samples · oha 1.15.0

Wed, 09 Sep 2026 05:01:39 GMT

every row ranked

dunx vs raw Bun.serve

92.1-99.7%

of the ceiling, across 5 scenarios. The rest is framework overhead.

Against the fastest rival

0W 3T 2L

Won 0, tied 3, lost 2 of 5. A gap inside ±3 points is a tie on this setup, not a result.

Cold start

1.93x

46.2 ms against Bun.serve (raw)'s 24.0 ms - rank 6 of 20. dunx's clearest loss on this page.

Scenario by scenario

Scenario	dunx	Fastest rival	Rank	Verdict
Plain text	99.6%	Elysia 99.0%	2 / 20	tied
JSON	95.6%	Axum (Rust) 97.8%	3 / 20	tied
Path parameter	94.4%	Elysia 99.6%	4 / 20	behind
Body validation	92.1%	Axum (Rust) 93.7%	3 / 20	tied
Cache and database	99.7%	Axum (Rust) 127.1%	4 / 20	behind

How to read this

Compare within a runtime first. A Bun subject beating a Node one is a statement about Bun rather than about the framework, so the colour below encodes the runtime and the same Hono application is measured on both.
A gap under 3 points is noise on this setup, and a figure at or above 100% of raw Bun.serve is noise too: dunx dispatches through that API and cannot outrun it.
Only the cache-and-database scenario leaves the process. The other four are dispatch, serialisation and validation, all with zod, and their differences are rounding error next to one query - which is what the io row measures rather than asserts.

Full methodology, every subject's entry point and the harness itself: internal/bench.

Bun

Node

Rust

JVM

.NET

Python

@dunx/http

Plain text

GET /plaintext

GET returning a fixed text/plain body. Measures raw request/response dispatch.

Subject	Throughput vs raw Bun.serve	req/s	± stddev	p50 ms	p99 ms	peak MiB	cpu ms/kreq
Bun.serve (raw)	100.0%	134,478	514	0.453	0.914	47.1	7.70
@dunx/http	99.6%	133,993	1,203	0.458	0.921	61.5	7.76
Elysia	99.0%	133,151	1,698	0.459	0.930	54.8	7.88
Axum (Rust)	94.4%	126,969	1,202	0.499	0.553	4.8	7.89
Hono (Bun)	92.1%	123,815	2,455	0.495	0.999	52.5	8.44
ASP.NET Core minimal APIs	82.3%	110,649	2,356	0.558	0.803	98.8	11.32
ASP.NET Core MVC	66.0%	88,702	1,311	0.697	0.982	104.4	13.57
@dunx/http (+ request logging)	59.9%	80,618	594	0.761	1.507	69.6	13.19
Gin (Go)	56.9%	76,480	418	0.831	1.910	22.5	13.09
net/http (Go)	55.8%	74,976	423	0.851	1.867	17.9	13.36
@dunx/http (+ request logging, @arkv/logger)	44.6%	59,967	1,230	1.000	1.991	76.3	17.57
node:http (raw)	39.7%	53,325	814	1.162	2.295	86.1	18.81
Spring Boot (JVM)	38.7%	52,073	77	1.205	1.721	352.3	28.79
Fastify (Node)	34.5%	46,443	1,456	1.355	1.814	92.9	22.12
Hono (Node)	30.6%	41,201	1,251	1.538	1.943	89.4	24.55
NestJS (Fastify)	27.6%	37,178	1,864	1.623	2.173	109.4	27.85
Express (Node)	20.5%	27,561	768	2.275	2.735	92.7	36.77
NestJS (Express)	14.6%	19,640	256	3.145	3.573	109.6	51.99
FastAPI (Python)	5.4%	7,321	71	8.725	9.012	44.1	136.34
Django (Python)	3.4%	4,538	18	14.022	15.308	73.6	220.01

JSON

GET /json

GET returning a small object serialised to JSON. Adds serialisation cost.

Subject	Throughput vs raw Bun.serve	req/s	± stddev	p50 ms	p99 ms	peak MiB	cpu ms/kreq
Bun.serve (raw)	100.0%	129,641	1,354	0.470	0.944	46.3	7.96
Axum (Rust)	97.8%	126,805	644	0.500	0.574	4.8	7.89
@dunx/http	95.6%	123,999	1,618	0.493	0.990	60.3	8.33
Elysia	94.3%	122,220	1,094	0.501	1.010	55.5	8.59
Hono (Bun)	86.9%	112,717	1,624	0.544	1.095	54.9	9.29
ASP.NET Core minimal APIs	81.6%	105,833	1,356	0.590	0.795	102.2	11.90
ASP.NET Core MVC	65.1%	84,393	1,744	0.734	1.016	106.7	14.14
@dunx/http (+ request logging)	59.4%	77,015	991	0.791	1.561	68.0	13.84
Gin (Go)	57.8%	74,874	866	0.850	1.955	22.4	13.37
net/http (Go)	57.4%	74,363	312	0.859	1.887	17.9	13.46
@dunx/http (+ request logging, @arkv/logger)	44.8%	58,051	828	1.046	2.082	70.3	18.33
Spring Boot (JVM)	39.5%	51,229	186	1.233	1.464	600.9	28.90
node:http (raw)	37.7%	48,882	1,811	1.285	2.502	86.2	20.53
Fastify (Node)	34.0%	44,040	1,505	1.392	1.843	92.1	23.37
NestJS (Fastify)	30.3%	39,254	1,152	1.577	2.458	109.7	26.32
Hono (Node)	28.5%	36,916	863	1.686	2.075	92.0	27.99
Express (Node)	20.3%	26,275	240	2.385	2.644	92.7	38.41
NestJS (Express)	13.9%	17,974	491	3.539	4.022	107.4	57.02
FastAPI (Python)	5.6%	7,258	22	8.802	9.061	44.0	137.71
Django (Python)	3.4%	4,425	45	14.389	16.098	73.9	225.74

Path parameter

GET /params/42

GET with one path parameter echoed back as JSON. Adds route-matching cost.

Subject	Throughput vs raw Bun.serve	req/s	± stddev	p50 ms	p99 ms	peak MiB	cpu ms/kreq
Bun.serve (raw)	100.0%	128,172	1,199	0.478	0.961	47.9	8.06
Elysia	99.6%	127,701	1,358	0.482	0.974	56.4	8.20
Axum (Rust)	95.7%	122,718	880	0.514	0.633	4.8	8.14
@dunx/http	94.4%	120,942	2,130	0.498	1.007	61.5	8.58
Hono (Bun)	84.8%	108,669	1,434	0.564	1.133	54.1	9.66
ASP.NET Core minimal APIs	82.0%	105,077	2,309	0.596	0.819	99.9	11.83
@dunx/http (+ request logging)	59.0%	75,577	1,144	0.807	1.600	69.5	14.12
Gin (Go)	58.3%	74,708	415	0.850	1.969	22.5	13.40
net/http (Go)	57.3%	73,448	838	0.870	1.897	17.6	13.62
ASP.NET Core MVC	53.1%	68,123	1,740	0.903	1.240	105.9	17.24
@dunx/http (+ request logging, @arkv/logger)	44.4%	56,899	1,301	1.074	2.144	64.7	18.75
node:http (raw)	36.9%	47,348	1,560	1.355	2.476	86.0	21.24
Spring Boot (JVM)	34.7%	44,459	1,014	1.414	1.769	628.8	33.03
Fastify (Node)	34.0%	43,568	699	1.422	1.930	92.2	23.45
NestJS (Fastify)	26.6%	34,110	490	1.806	2.242	109.0	30.22
Hono (Node)	26.6%	34,043	1,096	1.809	2.324	93.9	30.34
Express (Node)	19.9%	25,443	422	2.456	2.927	91.2	39.95
NestJS (Express)	13.6%	17,446	446	3.637	4.086	108.3	57.98
FastAPI (Python)	5.2%	6,677	55	9.549	9.996	43.3	149.78
Django (Python)	3.4%	4,363	84	14.508	15.838	72.5	228.91

Body validation

POST /validate

POST with a JSON body parsed and validated against the same zod schema in every subject, echoed back.

Subject	Throughput vs raw Bun.serve	req/s	± stddev	p50 ms	p99 ms	peak MiB	cpu ms/kreq
Bun.serve (raw)	100.0%	90,015	892	0.687	1.369	51.0	11.53
Axum (Rust)	93.7%	84,320	3,397	0.758	0.812	5.5	11.86
@dunx/http	92.1%	82,903	1,551	0.727	1.460	68.2	12.58
Elysia	89.3%	80,372	1,074	0.757	1.520	57.2	13.21
ASP.NET Core minimal APIs	86.2%	77,560	2,309	0.798	1.097	101.9	15.26
Hono (Bun)	73.6%	66,288	1,585	0.912	1.819	55.7	15.95
@dunx/http (+ request logging)	64.0%	57,602	889	1.060	1.979	73.0	18.49
ASP.NET Core MVC	59.0%	53,127	976	1.169	1.614	107.3	21.18
Gin (Go)	56.1%	50,459	70	1.269	2.826	22.5	19.88
net/http (Go)	55.4%	49,884	346	1.288	2.773	17.2	20.07
@dunx/http (+ request logging, @arkv/logger)	48.4%	43,607	1,287	1.390	2.718	71.0	24.52
Spring Boot (JVM)	37.7%	33,944	561	1.829	2.233	635.0	41.42
node:http (raw)	35.6%	32,013	1,364	1.888	3.734	90.4	31.84
Fastify (Node)	25.1%	22,584	403	2.620	9.675	258.6	52.47
Hono (Node)	22.5%	20,225	918	3.096	5.751	105.7	49.70
NestJS (Fastify)	22.0%	19,788	474	3.064	7.645	278.1	58.25
Express (Node)	19.2%	17,312	441	3.642	4.401	97.4	58.17
NestJS (Express)	14.6%	13,122	280	4.815	5.479	115.0	77.17
FastAPI (Python)	4.9%	4,403	23	14.502	14.887	44.2	227.13
Django (Python)	4.7%	4,199	61	15.132	16.780	73.8	237.85

Cache and database

GET /io

GET reading one key from Redis and then one indexed row from Postgres with a bound parameter, merged into one JSON object.

Subject	Throughput vs raw Bun.serve	req/s	± stddev	p50 ms	p99 ms	peak MiB	cpu ms/kreq
Axum (Rust)	127.1%	35,228	246	1.810	2.094	6.1	28.36
Elysia	100.1%	27,741	248	2.296	3.516	66.3	38.41
Bun.serve (raw)	100.0%	27,721	191	2.308	3.524	60.5	38.26
@dunx/http	99.7%	27,646	347	2.305	3.597	71.9	38.74
Hono (Bun)	95.6%	26,494	518	2.406	3.782	64.1	40.69
@dunx/http (+ request logging)	89.2%	24,734	363	2.553	4.188	78.2	44.35
@dunx/http (+ request logging, @arkv/logger)	81.2%	22,517	111	2.838	4.494	80.6	47.83
ASP.NET Core minimal APIs	77.0%	21,355	261	2.963	3.940	122.7	68.45
Gin (Go)	75.6%	20,945	254	2.964	4.355	28.1	47.71
net/http (Go)	74.9%	20,764	239	2.995	4.318	23.1	48.12
ASP.NET Core MVC	67.2%	18,623	137	3.391	4.658	129.0	77.24
Fastify (Node)	52.4%	14,520	415	4.323	5.881	121.8	70.54
node:http (raw)	51.5%	14,267	612	4.317	6.040	113.2	72.12
NestJS (Fastify)	47.4%	13,140	383	4.736	6.671	158.3	77.79
Hono (Node)	46.5%	12,899	424	4.804	6.422	145.5	79.13
Express (Node)	39.5%	10,959	432	5.679	7.670	130.0	93.11
NestJS (Express)	35.8%	9,911	239	6.237	8.331	159.9	103.76
Spring Boot (JVM)	17.8%	4,944	44	12.898	14.341	367.8	109.19
FastAPI (Python)	7.7%	2,130	14	29.085	45.828	64.6	469.69
Django (Python)	5.7%	1,580	21	40.461	43.469	104.9	441.49

Cold start

Process spawn to first served request, median of 7 samples. Polled at about 1 ms, so treat anything under 5 ms as a tie.

Subject	median ms	min ms	max ms	vs Bun.serve
Axum (Rust)	1.7	1.6	1.9	0.07x
net/http (Go)	4.0	3.8	4.3	0.17x
Gin (Go)	5.0	4.1	5.3	0.21x
Bun.serve (raw)	24.0	22.5	25.1	1.00x
Hono (Bun)	27.4	26.3	28.8	1.14x
@dunx/http	46.2	43.2	47.1	1.93x
@dunx/http (+ request logging)	46.6	44.6	48.1	1.94x
Elysia	51.9	49.0	57.0	2.17x
@dunx/http (+ request logging, @arkv/logger)	61.4	55.8	63.4	2.56x
node:http (raw)	80.7	76.3	83.3	3.37x
Hono (Node)	95.5	90.2	97.9	3.99x
Express (Node)	110.1	108.4	115.0	4.60x
Django (Python)	131.4	128.0	132.8	5.48x
Fastify (Node)	135.4	131.2	138.3	5.65x
NestJS (Express)	243.7	231.0	258.2	10.17x
FastAPI (Python)	244.0	239.9	245.6	10.19x
NestJS (Fastify)	251.8	246.1	261.4	10.51x
ASP.NET Core MVC	297.8	292.1	305.9	12.43x
ASP.NET Core minimal APIs	299.6	281.2	312.9	12.51x
Spring Boot (JVM)	1322.5	1274.7	1358.0	55.21x

Memory

Resident set of the whole process tree, read from /proc at 20 Hz inside each measured window. Boot is taken after the first served request and before any load; peak is the highest sample under it. Runs are seconds long, so neither says anything about heap growth at hour six.

Subject	boot MiB	peak MiB	processes
Axum (Rust)	3.5	6.1	1
net/http (Go)	12.4	23.3	1
Gin (Go)	17.5	28.4	1
Bun.serve (raw)	34.6	62.8	1
FastAPI (Python)	43.0	64.6	1
Hono (Bun)	36.6	66.5	1
Elysia	47.2	68.9	1
@dunx/http	51.3	72.6	1
@dunx/http (+ request logging)	52.1	79.2	1
@dunx/http (+ request logging, @arkv/logger)	54.8	85.8	1
Django (Python)	73.5	104.9	2
ASP.NET Core minimal APIs	76.4	123.4	1
ASP.NET Core MVC	80.6	129.8	1
node:http (raw)	72.6	137.8	1
Express (Node)	73.7	139.6	1
Hono (Node)	77.2	148.4	1
NestJS (Express)	99.0	181.6	1
Fastify (Node)	79.1	269.1	1
NestJS (Fastify)	99.3	278.4	1
Spring Boot (JVM)	259.2	635.0	1

Stability

Throughput answers how fast one request is. This answers whether the process survives the night. bun run soak drives 28 weighted operations against the full example - HTTP, websocket churn, SQLite, Redis, S3, the queue, the outbound client, guards, auth, validation failures and rate limiting - and fits the settled heap across rounds rather than the in-flight series, which measures the allocator instead of a leak.

3,668,137

calls in 365s

10,051/s

sustained

failures

25.1 to 25.0 MiB

settled heap, 12 rounds

The same harness runs in CI at 40 seconds and concurrency 12, which is too short for a leak verdict and long enough to catch an unexpected status, a stalled loop, a subscriber that outlived its socket, and a shutdown that hangs.