---
title: "Hono vs Elysia vs Express: Backend Frameworks for Bun in 2026"
author: "Nate Laquis"
author_role: "Founder & CEO"
date: "2029-08-30"
category: "Technology"
tags:
  - Hono vs Elysia Bun framework comparison
  - Bun backend frameworks 2026
  - Elysia Bun performance benchmarks
  - Hono multi-runtime framework
  - Express Bun compatibility
excerpt: "Bun adoption grew 300% in 2026, and three backend frameworks are competing for the ecosystem. Elysia is the fastest, Hono is the most portable, and Express just works. Here is how to pick the right one for your project."
reading_time: "13 min read"
canonical_url: "https://kanopylabs.com/blog/hono-vs-elysia-vs-express-for-bun"
---

# Hono vs Elysia vs Express: Backend Frameworks for Bun in 2026

## Bun Changed the Backend Game, and Frameworks Had to Catch Up

Bun hit 1.0 in September 2023. By mid-2026, it had grown 300% in monthly downloads, crossing 8 million installs per month on npm. Startups adopted it for the speed. Larger teams adopted it because Bun's all-in-one toolkit (runtime, bundler, test runner, package manager) eliminated three or four separate tools from their stack. The runtime itself was never the bottleneck, though. The real question became: which framework should you actually build on?

Three serious contenders emerged. Hono, the standards-based framework that runs on every JavaScript runtime including Bun. Elysia, the Bun-native framework that squeezes every ounce of performance from the runtime. And Express, the old reliable that gained a second life when Bun shipped Node.js compatibility mode. Each one makes different tradeoffs, and picking the wrong one will cost you months of refactoring when your needs evolve.

We have shipped Bun-based backends for multiple clients at Kanopy Labs since early 2025, and we have real opinions about when each framework fits. This is not a rehash of "hello world" benchmarks. We are going to cover the things that actually matter when you are maintaining a production API: type safety, middleware ecosystems, deployment targets, and the developer experience of building real features day after day.

![Backend developer comparing Hono Elysia and Express frameworks for Bun runtime in a code editor](https://images.unsplash.com/photo-1555949963-ff9fe0c870eb?w=800&q=80)

## Framework Philosophies: Three Very Different Bets

Before we get into benchmarks and features, it helps to understand the core bet each framework is making. The philosophy shapes everything from the API surface to the plugin system to where your code can actually run.

### Elysia: Built for Bun, Only for Bun

Elysia is authored by SaltyAom and designed from the ground up to exploit Bun's internals. It uses Bun's native HTTP server (Bun.serve), Bun's built-in SQLite driver, Bun's file I/O, and Bun's FFI for calling native code. The result is a framework that is absurdly fast. Elysia does not pretend to be portable. It leans fully into the Bun runtime and accepts that your code will never run on Node.js, Deno, or Cloudflare Workers without a rewrite.

Elysia also bets heavily on end-to-end type safety. Its type system infers route parameters, query strings, request bodies, and response shapes without requiring any code generation. If you have used tRPC, the developer experience feels familiar, but it applies to a standard REST API rather than a custom RPC protocol.

### Hono: Standards First, Runtime Second

Hono, created by Yusuke Wada, builds on the Web Standards API (Request, Response, Headers, URL). Your Hono code runs on Bun, Node.js, Deno, Cloudflare Workers, Vercel Edge Functions, AWS Lambda, and Fastly Compute with a one-line adapter swap. Hono's bet is that runtime lock-in is a losing strategy. As we covered in our [Hono vs Express vs Fastify comparison](/blog/hono-vs-express-vs-fastify), this portability is Hono's defining advantage, and it extends perfectly into the Bun ecosystem.

Hono on Bun is not a compatibility shim. Bun natively implements the Fetch API and Web Standards, so Hono runs at near-native speed without any translation layer. You get portability without paying a meaningful performance tax.

### Express: Compatibility Mode

Express runs on Bun because Bun implements most of the Node.js API surface. You can literally run `bun run server.ts` on an existing Express app and it will likely work. The appeal is obvious: zero migration effort. Your existing Express middleware, your auth libraries, your validation logic, all of it carries over. But you are running Node.js-style code on a Bun runtime, which means you miss out on Bun-native features like Bun.serve optimizations, native SQLite, and the Fetch API pipeline.

## Performance Benchmarks: Elysia Wins Raw Speed, But Context Matters

Let us get the numbers out of the way. These benchmarks were run on an M2 MacBook Pro with Bun 1.2, using a simple JSON serialization endpoint and wrk2 for load testing. Single core, no clustering.

### Raw HTTP Throughput on Bun

- **Elysia:** 195,000 to 210,000 requests/second. Elysia compiles route handlers into optimized functions at startup and uses Bun.serve directly with zero abstraction layers. This is as close to raw Bun performance as a framework gets.

- **Hono:** 155,000 to 175,000 requests/second. Hono's RegExpRouter compiles all routes into a single regex at startup. The overhead versus Elysia comes from Hono's Web Standards abstraction layer, which adds roughly 15% latency per request on synthetic benchmarks.

- **Express on Bun:** 45,000 to 60,000 requests/second. Express running under Bun is roughly 3x faster than Express on Node.js (which typically hits 15,000 to 18,000 req/sec). Bun's faster HTTP parser and V8-alternative engine do the heavy lifting, but Express's middleware chain and linear route matching remain bottlenecks.

### Realistic API Benchmark (JWT Auth, Zod Validation, Drizzle ORM to PostgreSQL)

This is where the gap narrows significantly. When your route handler authenticates a JWT, validates the request body, queries PostgreSQL through Drizzle ORM, and serializes the response:

- **Elysia:** 8,200 to 9,500 req/sec

- **Hono:** 7,800 to 9,000 req/sec

- **Express on Bun:** 5,500 to 6,800 req/sec

The database round-trip (2ms to 8ms) dominates the response time, compressing the framework overhead into noise for most routes. Elysia still leads, but the gap between Elysia and Hono shrinks to roughly 5% to 10%. Express trails by 25% to 30%, which starts to matter at scale but will not be your bottleneck until you are handling thousands of concurrent connections.

The takeaway: if raw throughput on Bun is your primary concern (high-frequency APIs, WebSocket servers, real-time data pipelines), Elysia has a measurable edge. For standard CRUD APIs where database latency dominates, the performance difference between Elysia and Hono is negligible in production.

![Performance benchmark dashboard comparing Hono Elysia and Express request throughput on Bun runtime](https://images.unsplash.com/photo-1517694712202-14dd9538aa97?w=800&q=80)

## Type Safety and Developer Experience

Type safety has become a non-negotiable requirement for backend frameworks in 2026. The question is not whether a framework supports TypeScript (they all do), but how deeply types integrate into the request/response lifecycle.

### Elysia: Best-in-Class Type Inference

Elysia's type system is genuinely impressive. When you define a route with a body schema, Elysia infers the TypeScript type of the parsed body, the response type, the route parameters, and the query string parameters. All of this happens without code generation or a build step. You define validation inline using Elysia's built-in TypeBox integration, and the types flow through your handler automatically.

Elysia also supports end-to-end type safety with its Eden client. Similar to tRPC, Eden generates a fully typed client from your Elysia server definition, so your frontend TypeScript code knows the exact shape of every API response at compile time. If you rename a field on the server, the client breaks at build time, not in production. For teams building full-stack TypeScript applications, this is a significant advantage.

### Hono: Strong Typing with RPC Mode

Hono ships with a Zod-based validator middleware and an RPC mode that provides end-to-end type inference similar to Elysia's Eden. You define your request/response schemas with Zod, and Hono's `hc` (Hono Client) infers the types on the client side. The experience is slightly more manual than Elysia (you need to explicitly chain validators), but the result is equally type-safe.

Hono's advantage is that its Zod validators work identically across all runtimes. Your validation logic does not change whether you deploy to Bun, Cloudflare Workers, or Node.js. Elysia's TypeBox validators are tightly coupled to the Bun runtime.

### Express: Bolt-On Types

Express has community-maintained TypeScript definitions, but the framework was designed before TypeScript existed. You can add Zod validation with middleware like zod-express, but route parameters, query strings, and response bodies are not type-inferred from your handlers. You end up writing manual type annotations or using wrapper libraries that feel like afterthoughts. For new projects on Bun, Express's type story is the weakest of the three.

If type safety is a priority for your team (and in 2026, it should be), Elysia and Hono are both excellent choices. Elysia's inference is more automatic. Hono's is more portable. Express requires significantly more manual effort to achieve the same level of safety.

## Plugin Ecosystems and Middleware

A framework is only as useful as the ecosystem around it. Authentication, rate limiting, CORS, OpenAPI generation, database integrations. These are table stakes for any production API, and the quality of pre-built solutions varies dramatically.

### Express: The Largest Ecosystem, Full Stop

Express has 16 years of middleware. Passport.js, helmet, cors, express-rate-limit, multer, express-session. If you need something, there is probably an Express middleware for it. Most of these work on Bun with zero changes because Bun's Node.js compatibility handles the underlying APIs. This is Express's strongest argument for Bun adoption: you inherit the entire Node.js middleware ecosystem on day one.

### Hono: Growing Fast, Production-Ready Core

Hono ships with a solid set of built-in middleware: CORS, JWT authentication, bearer auth, basic auth, ETag, cache control, compression, and a logger. The Hono community has also built official middleware for OpenAPI spec generation (with Zod), rate limiting, GraphQL, tRPC integration, and Sentry error tracking. The ecosystem is smaller than Express, but the middleware that exists is well-maintained and designed for modern standards.

Because Hono uses Web Standards, you can also use any Fetch API-compatible library as middleware. This opens up a broader set of tools than framework-specific plugins. Libraries like jose (JWT), oslo (auth utilities), and drizzle-orm work natively with Hono on Bun without adapters.

### Elysia: Bun-Native Plugins

Elysia has a plugin system that leverages Bun-specific features. The official plugins include JWT auth, CORS, static file serving, GraphQL (via GraphQL Yoga), Swagger/OpenAPI generation, and rate limiting. Elysia's plugins tend to be more tightly integrated with the framework's type system, so adding a JWT plugin automatically types the decoded payload in your route handlers.

The downside is ecosystem size. Elysia has roughly 60 to 70 community plugins compared to Hono's 150+ and Express's thousands. For common use cases, Elysia has you covered. For niche requirements (specific OAuth providers, legacy protocol support, specialized file processing), you may need to write custom middleware. For teams already maintaining [Node.js or Python backends](/blog/nodejs-vs-python-backend), the smaller ecosystem can mean more custom code during migration.

## Production Readiness and Deployment

Benchmarks and type systems are great in development. Production readiness is about what happens at 3 AM when your API starts throwing 500 errors under load.

### Express on Bun: Battle-Tested Logic, Newer Runtime

Express itself is one of the most battle-tested frameworks in web development history. The middleware you rely on has been hardened across billions of production requests. The risk factor is Bun's Node.js compatibility layer. While Bun 1.2+ handles the vast majority of Express use cases correctly, edge cases still surface. Certain streaming patterns, some native addons, and a few obscure EventEmitter behaviors can break under Bun. Test thoroughly before deploying, especially if your Express app uses native C++ addons.

### Hono: Production-Proven Across Multiple Runtimes

Hono is used in production by Cloudflare (internally), Vercel, and hundreds of companies running on Workers and Bun. The framework is actively maintained with weekly releases and a predictable deprecation policy. Hono's multi-runtime testing means bugs get caught across five or six different environments, which tends to produce more robust code than single-runtime frameworks.

Deploying Hono on Bun is straightforward. You can deploy to any platform that supports Docker containers (Railway, Fly.io, AWS ECS, Google Cloud Run), and Hono's edge adapters let you deploy the same codebase to Cloudflare Workers or Vercel Edge Functions for latency-sensitive routes. Our [Vercel vs AWS vs Railway comparison](/blog/vercel-vs-aws-vs-railway) covers deployment platform tradeoffs in detail.

### Elysia: Maturing Rapidly

Elysia reached 1.0 in early 2025 and has been stable since. Several high-traffic APIs run on Elysia in production, including real-time gaming backends and fintech data pipelines. The framework's error handling has matured significantly, with structured error responses, lifecycle hooks for logging and monitoring, and OpenTelemetry integration for distributed tracing.

The production risk with Elysia is lock-in. If Bun encounters a critical bug or performance regression, you cannot fall back to Node.js without rewriting your server entry point and replacing Bun-specific APIs. Hono gives you that escape hatch. Express gives you that escape hatch. Elysia does not.

![Software development team reviewing production deployment metrics for Bun backend framework comparison](https://images.unsplash.com/photo-1504384308090-c894fdcc538d?w=800&q=80)

## Edge Deployment: Hono Pulls Ahead

Edge deployment is no longer a niche concern. In 2026, Cloudflare Workers processes over 50 billion requests per day. Vercel deploys to edge by default. Fastly Compute and Deno Deploy are both seeing significant enterprise adoption. If your API serves a global user base, deploying to edge locations cuts 50ms to 200ms of latency per request simply by running code closer to users.

### Hono: Deploy Everywhere

Hono is the clear winner for edge deployment. Your Bun-based Hono API can deploy to Cloudflare Workers by swapping one import line. The same route handlers, middleware, and business logic run at 300+ edge locations worldwide. For teams building APIs that serve both edge-cached responses (product catalogs, content feeds) and origin-processed requests (payment processing, database writes), Hono lets you split routes across deployment targets without maintaining separate codebases.

This matters for cost optimization too. Edge compute on Cloudflare Workers costs roughly $0.50 per million requests with generous free tiers. Running a comparable workload on a Bun server in a single region on Railway or Fly.io costs $5 to $20/month minimum, plus you eat the latency penalty for users far from your region.

### Elysia: Bun Only Means Server Only

Elysia cannot deploy to edge runtimes. Period. Cloudflare Workers does not run Bun. Vercel Edge Functions do not run Bun. Deno Deploy does not run Bun. If you choose Elysia, you are deploying to a server or container running the Bun runtime in one or a few regions. You can put a CDN in front of it (Cloudflare, Fastly, CloudFront), but you cannot push your application logic to the edge.

### Express: Same Limitation, Worse Performance

Express on Bun has the same edge deployment limitation as Elysia, with the added disadvantage of slower raw performance. You are locked to server-based deployment and you are leaving performance on the table compared to both alternatives.

For teams building global SaaS products, APIs consumed by mobile apps across multiple continents, or latency-sensitive real-time features, Hono's edge deployment story is a compelling enough advantage to outweigh Elysia's raw speed benefit. Your p99 latency drops more from deploying to the edge than from shaving 15% off framework overhead.

## Our Recommendation: Which Framework to Pick for Bun in 2026

After shipping Bun-based backends for over a year, here is our honest recommendation for each scenario.

### Choose Elysia When:

- **You are building a high-throughput API** where Bun-native performance matters: WebSocket servers, real-time data streaming, gaming backends, or APIs handling 10,000+ concurrent connections.

- **You are building a full-stack TypeScript app** and want the best possible end-to-end type inference between your API and your frontend. Elysia's Eden client is genuinely best-in-class.

- **You are committed to the Bun ecosystem** and do not need edge deployment or the ability to fall back to Node.js. If Bun is your runtime for the foreseeable future, Elysia extracts maximum value from it.

### Choose Hono When:

- **You need multi-runtime flexibility.** If there is any chance you will deploy to Cloudflare Workers, Vercel Edge, Deno Deploy, or need a Node.js fallback, Hono is the only framework in this comparison that supports it.

- **You are building a global API** and want to deploy latency-sensitive routes to edge locations while keeping database-heavy routes on origin servers.

- **You want the safest long-term bet.** Hono's adoption is growing faster than any other JavaScript framework in 2026. Its community, middleware ecosystem, and multi-runtime testing give it the broadest foundation.

### Choose Express on Bun When:

- **You have an existing Express codebase** and want Bun's performance benefits without a framework migration. Running Express on Bun gives you a 2x to 3x speed boost with zero code changes.

- **Your team knows Express deeply** and the project timeline does not allow for learning a new framework. Shipping on time matters more than optimal architecture.

- **You need a specific Express middleware** that has no equivalent in Hono or Elysia. Some niche middleware (legacy SAML auth, specific payment gateway SDKs) only exists for Express.

For most new projects starting on Bun in 2026, we recommend Hono as the default choice. Its performance on Bun is within 10% of Elysia, its type safety is strong, its edge deployment story is unmatched, and its ecosystem is growing the fastest. If you need absolute peak performance on Bun and you are certain you will never need another runtime, Elysia is the premium choice.

We help teams make these decisions every week at Kanopy Labs. If you are evaluating Bun for your next backend or planning a migration from Express on Node.js, [book a free strategy call](/get-started) and we will help you pick the right framework, runtime, and deployment platform for your specific requirements.

---

*Originally published on [Kanopy Labs](https://kanopylabs.com/blog/hono-vs-elysia-vs-express-for-bun)*