Wisp is in pre-release, self-hosted since GitHub suspended us. Install it, or see the changelog.

Wisp

Benchmarks

Each result has its date and machine. It also lists cells where Wisp is not ahead. The native TechEmpower tables are on the home page and in bench/tfb/RESULTS.md.

This site shows the numbers of the newest release only. In the Wisp repo, bench/suites.tsv names each suite and its summary file. That file names the release and the commit it measured. When a new release is out, each suite not measured at it shows "Not measured at X yet." in place of its numbers, until it is measured again. The stamps step of cargo run -q -p wisp-gate checks the stamps and the pages.

git clone https://code.wispweb.dev/wispdev/wisp
cd wisp
cargo run -r -p bench-run -- --paths fortunes

You need Rust. bench/README.md lists every option and the frameworks compared. It also says how the harness checks each path for identical output. Compare frameworks only from the same machine.

The harnesses (bench-run, rank, native-rank, edge, rust-fastest) check each server's body against fixed answers before they time it. None ranks a cell with a failed request (a non-200 or a socket error). None ranks a run without a steal reading or with steal over the bar. An error page served fast never ranks. Throughput is the median of the runs (the mean of the middle two for an even count), with min..max beside it. The kept run of a redone one is the last, never the best.

Native, Linux

Source: bench/tfb/RESULTS.md (generated from results.json). The tables use the TechEmpower plaintext and JSON tests. Our script follows the method of the TechEmpower wrk scripts. This is not an official TechEmpower result.

The machine is one rented bare-metal box (Latitude.sh): AMD EPYC 4245P with 6 cores, SMT off, governor performance, 46 GB, Ubuntu 24.04.5 with the stock kernel 6.8.0-147-generic. The server and wrk run on this one box over loopback. The server runs on CPUs 1 and 2 and wrk on CPUs 3 to 5. CPU 0 is for the operating system. Plaintext (pipeline depth 16) at 256, 1,024, 4,096 and 16,384 connections, JSON at 16, 32, 64, 128, 256 and 512. 5 runs of 15 s each in one session on 2026-11-04, the median of the valid runs. A cell gets a rank only from 5 valid runs. A cell where the median busy share of the busiest wrk CPU is 95% or more is a lower bound and gets no rank. The valid runs are in bench/tfb/results.json. The raw wrk output stays on the machine that ran it. The release is v1.0.0-pre.3 (tag 0d2d15a03). The run was measured with harness commit 53fb60aa6, product code equal to v1.0.0-pre.3 (tag bench-pre3-h3). Overlaps of the min-max ranges are ties.

On this kernel the buffer ring fails with os error 22, so Wisp lends buffers by PROVIDE_BUFFERS (the log line is wisp: io: io_uring, buffers by PROVIDE_BUFFERS). The mode with buffer rings is not measured here. On the Ubuntu HWE kernel 7.0.0-42 this tag hangs. The fix is on main and is not part of these numbers.

wrk has 3 CPUs. At the fastest Wisp cells wrk is at its limit, so those Wisp numbers are lower bounds ("at least") and get no rank. A lower bound is never a win. Actix Web sets its workers to the CPUs it can use. This is a change to the TechEmpower source, because actix-server 2.2.0 uses num_cpus::get_physical(), which ignores taskset.

Wisp against Actix Web, requests a second, median (min-max), no failed request in either:

CellWispActix Web
plaintext, 256 connections8,140,071 (7,999,669-8,261,022)3,584,014 (3,539,680-3,597,632)
plaintext, 1,024 connections7,435,938 (7,354,134-7,524,651)3,463,763 (3,443,651-3,486,277)
plaintext, 4,096 connections4,168,493 (4,015,847-4,199,627)2,635,305 (2,623,901-2,656,153)
plaintext, 16,384 connectionsat least 3,074,375 (3,037,851-3,101,150)2,678,570 (2,666,670-2,684,383)
JSON, 16 connections1,062,799 (1,035,579-1,085,302)836,762 (834,525-842,105)
JSON, 32 connectionsat least 1,112,891 (990,844-1,146,482)863,137 (858,326-868,752)
JSON, 64 connectionsat least 1,137,864 (1,082,224-1,210,581)864,493 (850,278-870,579)
JSON, 128 connections1,160,729 (1,084,176-1,175,062)869,717 (868,075-870,238)
JSON, 256 connectionsat least 1,201,502 (1,189,138-1,209,408)866,648 (862,702-874,941)
JSON, 512 connectionsat least 1,203,673 (1,202,687-1,214,242)878,655 (876,043-885,769)

Five cells are ranked wins: plaintext at 256, 1,024 and 4,096 connections, and JSON at 16 and 128. In each of them Wisp's range is above Actix Web's. In the other five cells wrk was at its limit, so the Wisp number is a lower bound and the cell has no rank.

Plaintext, pipelined, requests per second (median of the valid runs), by connections:

Contender2561024409616384
Wisp 8,140,0717,435,9384,168,493at least 3,074,375
Axum 2,390,2692,337,8071,937,8151,945,689
Actix Web 3,584,0143,463,7632,635,3052,678,570
Express 278,367275,254265,691263,735
Fastify 414,802407,688389,429384,202
Hono (Node.js) 217,621209,713209,633208,023
Hono (Bun) 603,962577,152569,190572,170
SvelteKit 104,89978,91177,59576,554
Next.js 14,02414,96215,12914,871
Nuxt 165,092121,836100,15396,166

Rows whose min-max ranges overlap are ties. .

JSON, requests per second (median of the valid runs), by connections:

Contender163264128256512
Wisp 1,062,799at least 1,112,891at least 1,137,8641,160,729at least 1,201,502at least 1,203,673
Axum 738,671746,081744,709742,803737,867749,723
Actix Web 836,762863,137864,493869,717866,648878,655
Express 241,238241,015239,173238,151237,476237,154
Fastify 322,590323,353320,599290,069290,954290,795
Hono (Node.js) 190,174188,357187,022185,848184,963180,357
Hono (Bun) 506,800520,752526,427518,388522,545521,814
SvelteKit 91,20796,14991,24391,69692,88689,831
Next.js 8,5868,6398,5018,5708,3568,494
Nuxt 187,113182,503174,662179,813179,332164,058

Rows whose min-max ranges overlap are ties: 16: Hono (Node.js) with Nuxt. 128: Hono (Node.js) with Nuxt. 256: Hono (Node.js) with Nuxt. 512: Hono (Node.js) with Nuxt.

What these numbers come from:

  • Driver fast path. The epoll and io_uring drivers receive, answer and send in their own turn without waking the connection's task, and for routes the build found never wait, http::on_driver answers without polling the future at all.
  • One pass over the request. The request line, headers and a JSON body are read in as few passes as possible, borrowed from the receive buffer instead of copied.
  • Pooled buffers. A connection holds buffers only while it has a request. Idle ones go back to a pool per thread.
  • No cost for what is off. HTTP/2 (feature h2) is noticed only where HTTP/1 already refused the bytes, so HTTP/1 pays nothing. Features a route does not use add no instructions, checked by the A/B described in What Is Checked below.

Twelve Frameworks, Native, Linux

Source: bench/native-rank/results/report.md and bench/quiet/summaries/native-rank/summary.md in the Wisp repo (bench/native-rank/README.md). Release 1.0.0-pre.3, Wisp 0d2d15a03 (measured with harness commit 53fb60aa6, product code equal to v1.0.0-pre.3, tag bench-pre3-h3) and eleven others, including ASP.NET Core (.NET 10, Kestrel), serve the same five routes. The machine is one rented bare-metal box (Latitude.sh): AMD EPYC 4245P with 6 cores, SMT off, governor performance, 46 GB, Ubuntu 24.04.5 with the stock kernel 6.8.0-147-generic. The server runs on CPUs 1 and 2 and oha on CPUs 3 to 5, over loopback on the same box, with 64 connections and 10 s runs, median of 5. There are 3 passes on 2026-11-04. Pass 1 runs in table order, pass 2 in reverse order and pass 3 in a mixed order. A value is the median of the 3 passes. CPU steal was 0%. On this kernel Wisp lends buffers by PROVIDE_BUFFERS, because the buffer ring fails with os error 22. The quiet-run summary has 540 cells and 501 are valid (93%). A cell whose 3 passes differ by more than 3% is "noisy" and has no value here. A cell is a lower bound ("at least") when its value is at or above 0.6 of the calibrated ceiling of oha. It gets no rank and no win. This is a different machine and load generator from the TechEmpower tables above, so the two do not compare. Cold start is spawn to the first 200 (median of the passes). Memory is the PSS sum of the server's processes after load. Memory cells have no spread rule, so a memory value can show as valid with a wide spread, for example SvelteKit in the native run. A memory rule is for the next measurement.

Framework/ text/json/params/list 1,000/json-bigCold (ms)Memory (MB)
Wispat least 787,289noisyat least 771,84954,29269,166noisy5
Actix Webat least 847,058at least 817,481at least 604,52655,86358,507noisy3
Axumat least 690,287at least 669,591at least 553,07857,053noisy44
Hono (Bun)at least 710,369at least 634,370at least 549,196noisy74,533noisy45
ASP.NET Coreat least 519,431at least 486,575427,00525,46653,12112386
Fastify357,462346,838327,8228,52760,713noisy186
Spring Bootnoisy182,428180,69825,449noisynoisy778
Express237,174225,118214,9258,43854,097noisy398
Go Gin350,874340,065305,0273,09944,635621
SvelteKitnoisynoisynoisy3,67535,856noisy3,429
FastAPI64,17955,88237,9125,0391,955noisy103
Next.js8,6188,2736,6342576,958235961

On /, /json and /params the fastest servers are at the limit of oha, so Wisp, Actix Web, Axum and Hono (Bun) have lower bounds there and no rank. The report puts each lower bound ahead of the ranked cells and gives it no rank. On /list and /json-big no cell is limited by oha. On /list Wisp has 54,292 against Actix Web 55,863 and Axum 57,053, so Wisp is not ahead there (4.8% behind Axum). The /list route of the Wisp app in this run is the one of harness commit 53fb60aa6, not the one of the tag: the item text was Item &lt;${i}&gt; &amp; co and is now ${format!("Item <{i}> & co")}. The effect on the /list rate may not be zero, and it is not measured. On /json-big Wisp has 69,166, and Hono (Bun) has 74,533. Axum is noisy on /json-big. Server CPU time per request is not limited by oha: on /, /json and /params Wisp uses 2.0, 2.0 and 2.2 microseconds, Actix Web 2.3, 2.4 and 3.3, and Axum 2.7, 2.8 and 3.4. Where Wisp does not win: memory, 5 MB after load against Actix Web 3, Axum 4 and Gin 21, and the /list throughput above.

Leptos, Dioxus and Actix Web: Instructions per Request

Release 1.0.0-pre.3, Wisp 2362ec0d, 2026-10-26. Instructions per request on the server thread (callgrind, one CPU, 100 warm-up and 1,000 measured requests), median of 3 reps (min-max), release builds. Source: bench/rust-fastest/results/ir.txt and ir-provenance.txt in the Wisp repo. Wisp is not measured at 1.0.0-pre.3: the spread of its 3 reps was above 1%.

RouteLeptosDioxusActix Web
/plaintext14,341 (14,341-14,344)13,750 (13,749-13,754)17,123 (17,118-17,129)
/json14,906 (14,902-14,907)14,294 (14,293-14,295)17,829 (17,815-17,862)
/fortunes (13 rows, escaped, no database)165,437 (165,412-165,443)470,141 (469,546-471,754)43,815 (43,811-43,818)

Build Time and Dev Reload, Linux Bench Box

Source: bench/build/results/report.md and summary.json in the Wisp repo (node bench/build/measure.mjs run <contender> --runs 3), release 1.0.0-pre.3, Wisp 0d2d15a0 (the run used 1e85167d: the tag plus bench-only commits), 2026-10-27. The bench/tfb apps ran on the 4-core bench box (SMT off, kernel 6.8.0-146), all in one run. Each build ran under the bench lock after the machine drained, 3 runs per cell, the median. A run with steal over 10% would run again (none did: steal was 0% in every run). Cold is a clean build with dependencies already downloaded. Warm is the same command again. Dev reload is a file saved in the running dev server until GET serves the new text. Rank in brackets.

FrameworkCold buildWarm, no changeWarm, logic editWarm, template editDev, logic editDev, template edit
Wisp43.9 s (#5)38 ms (#1)14.9 s (#4)15.0 s (#3)1 ms (#1)48 ms (#2)
SvelteKit3.7 s (#1)3.7 s (#4)3.7 s (#1)3.7 s (#1)22 ms (#3)14 ms (#1)
Nuxt5.1 s (#2)5.0 s (#5)5.0 s (#2)5.0 s (#2)895 ms (#6)143 ms (#3)
Next.js19.8 s (#3)17.8 s (#6)17.8 s (#6)17.9 s (#4)211 ms (#4)332 ms (#4)
Axum28.6 s (#4)57 ms (#2)13.5 s (#3)---
Actix Web67.5 s (#6)100 ms (#3)16.6 s (#5)---
Hono (Node)----254 ms (#5)-
Hono (Bun)----8 ms (#2)-
  • Where Wisp does not win: a cold build (43.9 s, against SvelteKit 3.7 s, Nuxt 5.1 s and Axum 28.6 s) and a release build after an edit (14.9 s for logic, 15.0 s for a template, against SvelteKit 3.7 s and Axum 13.5 s), because a release build compiles Rust with fat LTO. In the dev server, a template edit shows in 48 ms against SvelteKit's 14 ms. - means the framework has no such step (no build, or no dev server in its docs).
  • Dev, logic edit: a string literal edit swaps in without a compile (1 ms). A number or bool literal edit also swaps in. Any other Rust edit recompiles.

Node, Bun and Deno, Linux, Ranked Run

Wisp against the popular frameworks of each host, bench/rank. Release 1.0.0-pre.3, Wisp 0d2d15a03 (measured with harness commit 53fb60aa6, product code equal to v1.0.0-pre.3, tag bench-pre3-h3), 2026-11-04. The machine is one rented bare-metal box (Latitude.sh): AMD EPYC 4245P with 6 cores, SMT off, governor performance, 46 GB, Ubuntu 24.04.5 with the stock kernel 6.8.0-147-generic. The server and oha run on this one box over loopback. Servers run on CPUs 1 and 2 and oha on CPUs 3 to 5. 64 connections, 10 s runs, median of 5 runs per cell, cold start median of 15 starts, memory as RSS of a fresh server after exactly 80,000 requests (20,000 on each route). Node v24.21.0, Bun 1.4.4, Deno 2.9.8. Memory cells have no spread rule, so a memory value can show as valid with a wide spread. A memory rule is for the next measurement. CPU steal was 0% in every run. No server redid a run after a connection reset on Node, Bun or Deno. The run has 3 repeats. The quiet-run summary has 599 cells and 551 are valid (92%). Each value below is from the last repeat. The median of the 3 repeats is in bench/quiet/summaries/rank/summary.md. It differs by at most 2.3% over the valid req/s cells. A cell whose repeats differ by more than 3% is "noisy" and has no value. A number with no place has a noisy rival in that cell. It can also have a tie: its min-max range over the repeats overlaps that of a rival. Wisp has no place in either case. Source: bench/rank/results/{node,bun,deno}.json and report.md in the Wisp repo. Req/s, place among the frameworks in brackets (the second Wisp row is not counted against the first):

HostFramework//list1000/json-big/paramscold start msRSS MB
NodeWisp (raw sockets, default)282,80515,21743,720261,6302680 (#1)
NodeWisp node:http150,23513,83135,331114,4962699 (#1)
NodeFastify138,9784,31227,286127,91762234 (#2)
NodeHono134,428noisy27,096107,559noisy248 (#4)

Node: the raw-socket default has the highest valid value in all four routes. It has no place in them, because a rival cell (SvelteKit, Next.js, Hono or Express) is noisy. Where Wisp does not win on Node: /params on node:http, 114,496 against Fastify 127,917 (10.5% behind).

Express, SvelteKit and Next.js on Node are in the report.

Bun, same run and source as Node above, bench/rank/results/bun.json:

HostFramework//list1000/json-big/paramscold start msRSS MB
BunWisp (raw sockets, default)407,546 (#1)noisy53,412 (#1)365,756 (#1)11 (#2)48 (#1)
BunWisp Bun.serve322,700 (#3)19,33249,684 (#1)259,845 (#2)10 (#2)64 (#1)
BunElysia392,406 (#2)noisy38,826 (tie)245,795 (#3)20 (#3)83 (#3)
BunHono370,767 (#3)noisy39,021 (tie)280,910 (#2)7 (#1)70 (#2)

Cold start on Bun, Wisp 11 ms against Hono 7. Bun / and /params on Bun.serve, 322,700 against Hono 370,767 (13% behind) and 259,845 against 280,910 (7% behind).

Deno, same run and source as Node above, bench/rank/results/deno.json:

HostFramework//list1000/json-big/paramscold start msRSS MB
DenoWisp (raw sockets, default)277,90514,28140,749 (tie)247,936 (#2)1772 (#1)
DenoWisp Deno.serve298,47113,17637,506 (#2)223,894 (#2)1860 (#1)
DenoHono355,8604,84140,377 (tie)251,174 (#1)noisy113 (#2)

Deno /json-big on raw sockets is a tie: Wisp 40,749 and Hono 40,377 have overlapping ranges over the repeats, so neither has a place. Deno /, Hono 355,860 against Wisp 277,905 on raw sockets (22% behind) and 298,471 on Deno.serve (16% behind). Deno /params, Hono 251,174 against 247,936 on raw sockets (1% behind) and 223,894 on Deno.serve (11% behind). Deno /json-big on Deno.serve, 37,506 against Hono 40,377 (7% behind). Fresh and Oak on Deno are in the report.

workerd (below): Wisp is first on /, behind Hono and itty in cold start and behind Hono in memory.

workerd, Linux, Ranked Run

Wisp 0d2d15a03 (release 1.0.0-pre.3, measured with harness commit 53fb60aa6, product code equal to v1.0.0-pre.3, tag bench-pre3-h3) against six other contenders on workerd 2026-10-01, bench/rank (HOSTS=workerd), 2026-11-04. The machine is the same box as above: Latitude.sh bare metal, AMD EPYC 4245P, kernel 6.8.0-147-generic, servers on CPUs 1 and 2, oha on CPUs 3 to 5, over loopback. 64 connections, 10 s runs, median of 5 runs per cell, cold start median of 15. CPU steal was 0% (max 0%). 3 repeats, each value from the last repeat. Req/s, place among the frameworks in brackets, with a noisy cell shown as "noisy":

RouteWispHonoitty
/42,503 (#1)41,176 (#2)38,123 (#3)
/list100010,916noisynoisy
/json-big20,54819,10218,210
/params39,73137,523noisy

Wisp is first on / by 3% over Hono. On /list1000, /json-big and /params Wisp has the highest valid value but no place, because a rival cell is noisy. Cold start (process start to the first right 200): Wisp 19 ms (#3), Hono 13 (#2), itty 12 (#1). Wisp loses cold start by 6 ms to Hono. Memory (RSS of a fresh server after exactly 80,000 requests, 20,000 on each of the 4 routes, one contender at a time): Hono 335 MB (#1), Wisp 369 (#2), react-router 440, itty 479, astro 553, next 923, sveltekit 1,491. Wisp loses cold start and memory to Hono. Source: bench/rank/results/workerd.json and report.md.

Connection resets. workerd resets a few connections at the start of some timed runs, whatever it serves. A run whose only failures are such resets is redone, for every app alike, and the last try is kept, never the best. The cap is 12 tries (max_tries in the results file). Any other failure (a wrong status, a timeout) is never redone and fails the cell. This run redid 29 of its 140 timed runs, 6 of them Wisp's. The most tries for one run was 4 of 12. Each redo is listed in the report. Source: bench/edge/util.mjs (RESET_TRIES).

V8 drops the Liftoff code that the warm-up compiled once a worker sits idle, so the next request compiles its functions again. The cost is roughly linear in body bytes, and V8 flags cannot be set on Workers. The wasm build therefore shares one trampoline between routes instead of compiling a polling function for each.

Edge and JavaScript Hosts: Instructions per Request

Release 1.0.0-pre.3, Wisp 2362ec0d, 2026-10-26. What each server's process does per request, counted by perf stat instead of timed: user instructions of the server's process over oha -n 40000 -c 64, divided by the requests. Same 6 vCPU VPS, servers on cores 0-1, oha on 2-3. Each of three runs gives the median of 3 reps, and the table gives the median of the runs. A cell with - is not valid (fewer than 3 runs, or a spread (max - min) / median of 1% or more). Wisp raw sockets and workerd have no valid cell and are left out. k = thousand, M = million instructions. Lower is better. Source: bench/edge/README.md ("Latest pass") in the Wisp repo.

HostServer//json-big/params/list1000/form/table
NodeWisp node:http84.35k611.01k71.93k2.12M162.62k-
NodeHono72.98k507.42k78.02k5.98M--
DenoWisp Deno.serve29.98k742.26k49.27k2.50M--
DenoHono19.26k517.03k42.14k6.20M--

The Bun rows are left out: their warm-up was 3000 requests, too short for Bun's JIT (counts spread 14% to 19%). ir.mjs now warms Bun with 50000 requests and counts 200000 (spread under 0.5%). The cold start counts moved 2% to 15% between runs, so they are not published. The Cloudflare wasm of this bench app (bench/rank/out/wisp-cf/app.wasm) is 463,900 bytes, 177,024 with gzip -9.

What Is Checked

CheckWhat it does
Instructions per requestA change that touches the request path runs A/B against the build before it, counting CPU instructions for the same requests. A feature a route does not use must add none.
Startup self-testsEach fast path (the I/O driver, parsers, caches) is proven at server start, and falls back to the plain path if the proof fails.
Validity per cellbench/quiet checks each cell on its own: its spread over the repeats must stay in the limit. A run is publishable when the gates pass and at least 90% of its cells are valid. A table shows a cell that is not valid as "noisy, not shown", and a cell that is missing in a repeat as "missing, not shown". A Wisp cell with a rival not shown gets no place: "valid cells only, N rival(s) noisy". A connection count with no calibration blocks the run.
Comparable frameworksbench/ holds the same server-rendered page, JSON and plaintext routes written the way each framework's docs would write them, a load generator and a runner.

Tokens

Writing cost is measured by a program in the repository: cargo run -p wisp-tokens --release. See Tokens.

Is This Page Useful?

View This Page's Source

Type to search every docs page and heading.