Elysia vs Hono vs Fastify: TypeScript API Frameworks in 2026

Q: When to Choose Each Framework?

Choose Elysia if: You're committed to Bun as your runtime End-to-end TypeScript type safety (client + server) is a priority You're building a new greenfield project where ecosystem maturity matters less You want maximum raw throughput on Bun Choose Hono if: You're deploying to edge runtimes (Cloudflare Workers, Vercel Edge) Runtime portability matters — you might change where the API runs You want a lightweight framework with minimal opinion on data layer You're building a backend-for-frontend o

TL;DR

Elysia dominates raw throughput on Bun (71,202 ops/sec with validation) and offers unmatched end-to-end type safety via Eden. Hono is the pragmatic cross-runtime choice — 9.3M weekly npm downloads, 28k GitHub stars, and it runs on Cloudflare Workers, Bun, Deno, and Node.js without changing a line of code. Fastify remains the mature Node.js default for teams that need a battle-tested plugin ecosystem and don't want to adopt Bun yet. The right choice depends almost entirely on your runtime and type safety requirements.

Key Takeaways

Elysia is the fastest for Bun-native APIs — 71,202 ops/sec vs Hono's 62,207 and Fastify's 15,707 (schema validation benchmarks, 2026)
Hono leads npm growth at 26.6% month-over-month vs Elysia's 17.9%, with 9.3M weekly downloads
Fastify has the deepest ecosystem — 300+ plugins, enterprise production track record since 2016
Hono runs everywhere — Cloudflare Workers, Bun, Deno, Node.js, AWS Lambda, Vercel Edge — no code changes
Elysia requires Bun — it works on Node.js but loses most of its performance advantage
Eden (Elysia's RPC client) is a DX game-changer — full end-to-end TypeScript types with zero codegen

Why This Comparison Matters in 2026

The TypeScript API framework landscape fractured in 2025. For a decade, the decision was simple: Express for quick prototypes, Fastify for production Node.js. Then Hono and Elysia arrived and complicated everything.

Hono crossed 28,000 GitHub stars in early 2026 with 9.3 million weekly npm downloads — making it more downloaded than Fastify by some measures. Elysia, while younger, is used by over 10,000 open-source projects and posts benchmark numbers that make Fastify look sluggish.

But raw stars and downloads obscure a critical architectural difference: these three frameworks are built for fundamentally different runtimes and use cases. Conflating them in a simple "which is faster" comparison misses the point.

This guide breaks down the real decision matrix: runtime target, team size, type safety requirements, and production readiness.

Performance Benchmarks: The Numbers That Matter

Raw benchmark numbers are slippery — they depend heavily on what you measure. Here's what current 2026 data shows across three scenarios.

Scenario 1: Schema Validation Under Load (Most Realistic)

When benchmarked with request body validation enabled (the realistic production scenario), results shift dramatically from the "hello world" benchmarks that inflate Elysia's advantage:

Framework	Ops/sec (validated)	Runtime
Elysia 1.4	71,202	Bun 1.1
Hono 4.x	62,207	Bun 1.1
Fastify 5.x	15,707	Node.js 22

Elysia's advantage comes from its Sucrose static code analysis engine — it analyzes route handlers at startup and compiles optimized code paths, eliminating per-request overhead. Hono's advantage comes from its minimal middleware chain and Web Standards primitives.

Fastify's apparent slowdown is misleading context: it's benchmarked on Node.js, while the other two run on Bun. Node.js vs Bun runtime differences account for a significant portion of the gap. On Node.js, Fastify benchmarks are competitive with Hono.

Scenario 2: Edge/Cloudflare Workers

On Cloudflare Workers, Hono is the clear winner — it's the only one of the three built specifically for the Workers V8 isolate environment. Elysia doesn't officially support Cloudflare Workers (its Bun-specific optimizations don't translate). Fastify's Node.js APIs aren't compatible with the Workers runtime.

Hono's Cloudflare Workers throughput consistently outperforms every other JS framework measured in that environment.

Scenario 3: Node.js Production Server

On Node.js 22 with clustering enabled, Fastify recovers significantly. Its JSON Schema-based validation compiles JSON parsing into optimized serializers, and the battle-tested plugin ecosystem handles the real-world complexity that benchmarks ignore (auth middleware, rate limiting, multi-tenant routing).

Bottom line: If your primary concern is raw ops/sec on Bun, Elysia wins. If you're deploying to edge/serverless, Hono wins. If you're running Node.js in production with complex middleware needs, Fastify wins.

Type Safety and Developer Experience

This is where the three frameworks diverge most dramatically for day-to-day development.

Fastify: JSON Schema as the Contract

Fastify uses JSON Schema for request validation and response serialization. It's powerful and battle-tested, but the TypeScript DX is indirect — you define a schema, then separately define TypeScript types that mirror it. Zod and Typebox plugins bridge this gap, but it requires extra setup.

// Fastify with TypeBox
const schema = {
  body: Type.Object({
    email: Type.String({ format: 'email' }),
    password: Type.String({ minLength: 8 })
  })
}

fastify.post('/login', { schema }, async (request, reply) => {
  // request.body is typed — but only after TypeBox setup
})

Hono: Web Standards + Zod Validator

Hono's validator middleware integrates directly with Zod, providing clean TypeScript inference without boilerplate:

// Hono with Zod validator
const route = app.post('/login',
  zValidator('json', z.object({
    email: z.string().email(),
    password: z.string().min(8)
  })),
  (c) => {
    const { email, password } = c.req.valid('json') // Fully typed
    return c.json({ success: true })
  }
)

// Client-side: hono/client for RPC-style calls
type AppType = typeof route

Elysia: Eden — End-to-End Types Without Codegen

Elysia's Eden is genuinely different. It derives full TypeScript types for your entire API surface — including request and response shapes — directly from your server code, with zero codegen:

// Elysia server
const app = new Elysia()
  .post('/login', ({ body }) => {
    return { token: generateToken(body.email) }
  }, {
    body: t.Object({
      email: t.String(),
      password: t.String()
    })
  })

// Eden client — fully typed, no codegen
const client = treaty<typeof app>('http://localhost:3000')
const { data } = await client.login.post({ email: 'x@y.com', password: 'abc123' })
//                                        ^ TypeScript error if wrong shape
//     ^ { token: string } — correctly inferred return type

If end-to-end type safety matters to your team — and in 2026 TypeScript-native teams, it increasingly does — Eden makes Elysia difficult to beat for new greenfield projects.

Runtime Portability: The Hidden Decision Factor

Before choosing a framework, answer this question: Where does your API need to run?

Hono's Multi-Runtime Advantage

Hono is built on Web Standards (Fetch API, Request/Response, Web Crypto). This means the same code runs on:

Cloudflare Workers — V8 isolates, sub-millisecond cold starts
Vercel Edge Functions — same primitives
AWS Lambda — via the aws-lambda adapter
Bun — native support, high performance
Deno — native support
Node.js — via the node adapter

This portability is a real production advantage. Teams that want to run the same API handler on Cloudflare Workers for US traffic and a Fly.io Bun instance for EU traffic — with a single codebase — use Hono.

Elysia's Bun-First Architecture

Elysia is designed for Bun. While it technically runs on Node.js, you lose the Sucrose optimization, the performance advantage, and some of the plugin ecosystem optimizations. Choosing Elysia means committing to Bun as your runtime — a bet that's increasingly reasonable in 2026 as Bun has stabilized, but still a constraint worth acknowledging.

Fastify's Node.js Depth

Fastify runs on Node.js and only Node.js (officially). This is actually a strength for teams that need the Node.js ecosystem — decades of battle-hardened packages, Node.js LTS guarantees, and infrastructure tooling designed for Node. If you're deploying to a Linux VM, a Kubernetes cluster, or any traditional server environment, Fastify's Node.js focus is an advantage, not a liability.

Ecosystem, Plugins, and Production Readiness

Fastify: Mature Plugin Ecosystem

Fastify has been in production since 2016 and has 300+ official and community plugins covering:

Authentication: @fastify/jwt, @fastify/oauth2, @fastify/session
Database: @fastify/postgres, @fastify/mongodb, @fastify/redis
Utilities: @fastify/cors, @fastify/helmet, @fastify/rate-limit, @fastify/multipart
Swagger/OpenAPI: @fastify/swagger with UI

The plugin lifecycle system (hooks, decorators, encapsulation) is sophisticated. Large teams building multi-module APIs — where different parts of the codebase need isolated plugin registrations — will find Fastify's encapsulation model valuable.

Hono: Growing Plugin Ecosystem

Hono's middleware library (hono/middleware) covers the essentials:

Built-in: CORS, logger, JWT, basic auth, compress, etag, timeout
Community: Zod validator, Swagger UI, rate limiting, session

The ecosystem is smaller than Fastify's but growing rapidly. The main gap: database integrations are thinner (Hono doesn't prescribe a data layer, which is intentional).

Elysia: Plugin System with End-to-End Types

Elysia's plugin system propagates type information through the chain — a plugin that adds an authentication context propagates those types to all downstream handlers. This is architecturally elegant. The ecosystem is smallest of the three, but for Bun-native apps, the key plugins are in place:

@elysiajs/swagger — OpenAPI generation
@elysiajs/jwt — JWT handling with typed payloads
@elysiajs/cors — CORS middleware
@elysiajs/static — static file serving
@elysiajs/cron — cron jobs

When to Choose Each Framework

Choose Elysia if:

You're committed to Bun as your runtime
End-to-end TypeScript type safety (client + server) is a priority
You're building a new greenfield project where ecosystem maturity matters less
You want maximum raw throughput on Bun

Choose Hono if:

You're deploying to edge runtimes (Cloudflare Workers, Vercel Edge)
Runtime portability matters — you might change where the API runs
You want a lightweight framework with minimal opinion on data layer
You're building a backend-for-frontend or API gateway layer

Choose Fastify if:

Your team is Node.js-native with no plans to change runtimes
You need a mature plugin ecosystem (auth, sessions, database integrations)
You're maintaining an existing Express app and want a structured migration path
Enterprise deployment requirements favor battle-tested, LTS-aligned tooling

Migration Considerations

From Express to Fastify: Direct migration path — Fastify has Express compatibility middleware. Route handlers follow similar patterns. Most Express middleware can be wrapped.

From Fastify to Hono: More involved — Fastify's plugin system doesn't map directly to Hono's middleware chain. Schema validation approaches differ. Worth it for edge portability.

From Hono to Elysia: Elysia has published an official migration guide. The main difference is validation syntax and the Eden client setup.

The 2026 Verdict

Elysia, Hono, and Fastify aren't competing for the same developer. They've carved out distinct positions:

Elysia = maximum TypeScript DX on Bun
Hono = portable Web Standards framework for edge-first teams
Fastify = production-grade Node.js with ecosystem depth

The "Elysia is 4x faster than Fastify" benchmark headline is technically correct and practically misleading — it's a Bun vs Node.js comparison as much as it is a framework comparison.

For new TypeScript projects starting in 2026: if you're deploying to Cloudflare Workers or need multi-runtime flexibility, Hono is the pragmatic default. If you're all-in on Bun and want elite DX, Elysia. If you're running Node.js in production and need a proven, plugin-rich foundation, Fastify hasn't been dethroned.

Methodology

Sources consulted: 8
Benchmark data: devpick.co Fastify vs Hono 2026, Encore.dev TypeScript frameworks analysis, official Hono benchmarks
GitHub stars: verified March 2026 (Hono: 28,190)
npm downloads: npmtrends data, March 2026 (Hono: 9.3M/week)
Date: March 2026

Explore the Hono vs Fastify vs Express comparison for a deeper Node.js-focused breakdown, or browse all API frameworks on APIScout to compare specs side-by-side.

Elysia vs Hono vs Fastify TypeScript APIs 2026