Hono: ultrafast, multi-runtime web framework for the edge and beyond

The JavaScript server ecosystem is fragmented: Cloudflare Workers, Deno, Bun, AWS Lambda, and Node.js each demand their own idioms, adapters, and deployment pipelines. Most frameworks pick one and call it done.

You end up maintaining parallel codebases, learning platform-specific quirks, or accepting a heavyweight abstraction that papers over the differences without truly solving them. The result is slower iteration, larger bundles, and routers that scan routes in linear loops — every request paying the tax of every route you've ever registered.

What you actually want is a single, expressive API that compiles once and deploys everywhere, backed by a router that was designed from the start to be fast — not retrofitted.

The problem

Hono is a web framework built entirely on the Fetch API, Request, Response, and the rest of the Web Standard surface. That's not a marketing claim — it's the architectural decision that makes multi-runtime deployment possible without shims or platform locks.

The core ships with built-in middleware, a JSX layer, streaming helpers, an SSG helper, and first-class TypeScript support — including typed route parameters, typed environment bindings for Cloudflare Workers, and typed context variables. The knowledge base indexes 702 public symbols across 7 components, so the surface is large enough to be complete and small enough to learn.

The big idea

Most framework benchmarks measure middleware overhead. Hono's benchmark suite measures the router itself — route registration, parameter extraction, and dispatch — against the most commonly used alternatives in the ecosystem.

RegExpRouter compiles your route table into a single regular expression rather than iterating handlers one by one. That means route-count stops being a performance variable. The benchmark suite in the repo tests against find-my-way, express, koa-router, koa-tree-router, trek-router, and @medley/router — run them yourself with npm run bench:node or npm run bench:bun and read the numbers directly.

HTTP-level benchmarks are also automated: every pull request runs a bombardier-based benchmark comparing the current branch against main, and results are posted as a PR comment. The performance contract is visible in the repository's own CI, not just in a README table.

The aha

When your router doesn't loop, adding routes doesn't cost you latency.

The repository is organized into seven components — hono (core), routers, jsx, query-param, utils, webapp, and hono-benchmark — with explicit internal dependency edges: jsx depends on hono, webapp depends on hono.

The core Hono class accepts generic type parameters for Variables and Bindings, giving you typed access to c.get()/c.set() and Cloudflare environment bindings like KVNamespace and R2Bucket at the call site — no casting required. Routes chain with middleware in a way that preserves those types end-to-end.

Middleware and adapters are exposed as separate package entrypoints (e.g. hono/bearer-auth, hono/aws-lambda, hono/bun) with matching ESM and CJS outputs, so bundlers only include what you import. The build pipeline produces both dist/index.js (ESM) and dist/cjs/index.js (CJS) alongside full type declarations under dist/types.

Architecture

Data flow

Because Hono runs on Web Standard APIs, the same application code is valid in radically different deployment contexts. Here are three representative shapes.

In the real world

The repo uses Bun as its primary toolchain. You will need Bun v1.0+ installed. For the HTTP benchmarks you will also need bombardier (brew install bombardier on macOS).

bun install --frozen-lockfile

1. Clone the repository Run git clone git@github.com:honojs/hono.git && cd hono to get a local copy.
2. Install dependencies Run bun install --frozen-lockfile. Bun resolves and installs all workspace dependencies from the lockfile — you will see a summary of installed packages with no network variance.
3. Run the test suite Run npm run test. This executes tsc --noEmit (type-check) followed by vitest --run. A passing run prints a vitest summary table showing test counts and durations per file — that's your signal everything is wired up correctly.
4. Start the webapp example Run npm run start (or npm run start:hono) to boot the example web application. You now have a live Hono server to inspect and modify.
5. Run a router benchmark Run npm run bench:bun (or npm run bench:node) inside the routers component. Results print a comparison table of Hono RegExpRouter and TrieRouter against find-my-way, express, koa-router, koa-tree-router, trek-router, and @medley/router — read the numbers directly from your machine.
6. What you have at the end A fully type-checked Hono workspace, a passing test suite across the core and middleware, a running example server, and benchmark baselines on your own hardware. From here, scaffold a new project with npm create hono@latest.

The Hono repository has been indexed into a 384-dimensional RVF knowledge base: 1035 passages covering 702 public symbols, 7 components, and 40 entrypoint commands. Download the pack to query Hono's API, middleware signatures, router internals, and migration history offline — without grepping source files.