Hono

Hono is a lightweight, ultrafast web framework for building HTTP APIs and full-stack web applications on Web Standard APIs (Request/Response, Fetch). Because it targets the platform rather than a specific runtime, the exact same application code runs unmodified on Cloudflare Workers, Deno, Bun, Node.js, Fastly Compute, AWS Lambda, and Vercel Edge Functions.

Its core is a router-agnostic, middleware-composable design: a pluggable router layer (RegExpRouter, TrieRouter, SmartRouter, and more) handles URL matching, a Koa-style compose function chains middleware around a single Context object, and dozens of first-party middleware modules cover authentication, CORS, caching, compression, JWT/JWK, and more. The hono/tiny preset stays under 12kB and has zero runtime dependencies, making it a common choice for edge and serverless workloads where cold-start size matters as much as raw throughput.

What You Get

• A chainable, Express-style routing API (app.get, app.post, .route(), .basePath()) with full TypeScript inference for path params and typed environment bindings.
• A pluggable router layer — RegExpRouter (fastest, precompiles routes into a single regex dispatch table), TrieRouter, LinearRouter, PatternRouter, and SmartRouter, which auto-selects the best one at runtime.
• Over 25 first-party middleware modules covering CORS, CSRF, basic/bearer/JWT/JWK auth, caching, compression, secure headers, request ID, logging, ETag, and body-limit.
• Runtime adapters for Cloudflare Workers/Pages, Deno, Bun, AWS Lambda, Lambda@Edge, Vercel, Netlify, and Service Workers, so the same handler code targets any of them.
• A built-in JSX renderer and streaming helpers for server-rendered HTML without pulling in a separate templating engine.
• A type-safe RPC client (hono/client) that infers request/response types directly from server route definitions for end-to-end type safety.

Common Use Cases

• Building HTTP APIs and backends-for-frontend (BFF) layers deployed to edge platforms like Cloudflare Workers or Fastly Compute.
• Serverless functions on AWS Lambda or Vercel where cold-start time and bundle size are critical.
• Full-stack applications combining Hono’s JSX renderer with client-side hydration for lightweight server-rendered UIs.
• Migrating Express-style Node.js APIs to modern, multi-runtime deployments without a framework rewrite.
• Type-safe client-server communication via the built-in RPC client for internal service-to-service calls.

Under The Hood

Architecture: Hono’s core (src/hono-base.ts) is a router-agnostic base class: HTTP-method calls like app.get() register [method, path, handler] tuples onto an injected Router implementation (src/router.ts defines the Router<T> interface with add()/match()). Request dispatch flows through compose() (src/compose.ts), a Koa-style middleware chain that recursively calls dispatch(i+1) around a single mutable Context object, threading next(), error handling (onError), and 404 fallthrough (onNotFound) through one closure. .route() and .basePath() let sub-apps be mounted with path prefixes by cloning the instance and remapping registered routes, giving Hono’s routing tree its compositional, Express-like feel while staying framework-agnostic underneath.

Tech Stack: Written entirely in TypeScript (99.7% of the codebase) targeting ES modules with a CJS build via a custom build/build.ts script (using esbuild). The package ships zero runtime dependencies — everything from JSX to streaming to the RPC client is implemented against Web Standard APIs (Fetch, Request, Response, ReadableStream), which is exactly what allows the same bundle to run on Cloudflare Workers, Deno, Bun, and Node.js without polyfills. Build tooling includes TypeScript’s native-preview compiler, publint for package export validation, and Bun as the primary dev/build runner.

Code Quality: The repo maintains 99 *.test.ts files directly alongside source (co-located unit tests) plus a separate runtime-tests/ tree that runs the same suite against Deno, Bun, Node, Fastly, Lambda, and Workerd projects via per-runtime Vitest configs — a strong signal that cross-runtime parity is treated as a first-class quality requirement rather than an afterthought. ESLint is configured with @hono/eslint-config plus stricter custom rules (no-explicit-any mostly enforced, unused-vars errors), and Prettier/editorconfig-checker enforce formatting. Public APIs and internal helpers alike carry JSDoc comments with @see links back to the hono.dev docs.

API Design: The chainable app.get(path, handler) / app.use(handler) surface mirrors Express closely enough to be immediately familiar, while TypeScript generics (Env, Schema, BasePath) thread typed path params, bindings, and typed JSON responses through the whole chain with no manual type annotations required from the developer. Getting started is a single new Hono() plus one route — no config file, no build step required for the base framework — and the hono/client RPC layer extends that same type inference to the HTTP client, so consumers get compile-time safety on API calls without a code-gen step.