Elysia

Elysia is a Bun-first TypeScript web framework that pairs an Express-like chainable API with end-to-end type safety, TypeBox validation and a JIT-compiled router that benchmarks at over 2.5 million requests per second. We rate it 86/100 — if your team has already committed to Bun (or is willing to), Elysia is the most ergonomic, type-safe and fastest backend framework available in 2026, with the only meaningful trade-off being a smaller community than Hono.

What is Elysia?

Elysia is an open-source TypeScript web framework created by SaltyAom and first released on December 4, 2022. It is purpose-built around Bun's runtime APIs — using Bun's HTTP server, file system primitives and hot reload directly — and it ships under the MIT license on GitHub at elysiajs/elysia, where it has crossed 18,200+ stars as of May 2026 with the most recent release being v1.4.28.

The pitch is straightforward: most TypeScript backend frameworks force you to choose between speed (Fastify, raw Bun.serve), portability (Hono runs everywhere), or developer experience (Nest, tRPC). Elysia argues you do not have to choose. Its chainable API derives compile-time types from runtime schemas using TypeBox, then exposes those types to your client through Eden Treaty — giving you Express-style routing with the safety of tRPC and benchmark numbers that beat both. It is also the framework Bun itself recommends in its official ecosystem docs.

Key Features of Elysia

• Bun-native performance: A JIT-compiled router benchmarks at 2.5M+ requests/second on Bun in a hello-world scenario, with realistic JSON + TypeBox validation routes still hitting roughly 33,000 req/s — about 3× faster than Express on Node and noticeably ahead of Hono on Bun in head-to-head tests.
• Eden Treaty (zero-codegen typed client): Import your server type into your frontend and call routes like local functions. No OpenAPI generation step, no schema sync scripts — change a route on the server, your client autocomplete updates immediately.
• TypeBox validation built in: The t namespace exposes JSON-schema-compliant validators for body, query, params, headers and response. Schemas double as runtime guards and TypeScript types — one source of truth.
• First-class OpenAPI: The @elysiajs/openapi plugin generates a complete OpenAPI 3.1 document and Swagger UI from your route definitions automatically — no decorators, no extra annotations.
• Plugin ecosystem: Official plugins for CORS, JWT, bearer auth, cron, GraphQL Apollo and Yoga, server-timing, static files and OpenTelemetry — plus integrations with Drizzle, Prisma, Better Auth, React Email, Astro, SvelteKit, Nuxt, Tanstack Start, Cloudflare Workers, Vercel and Netlify.
• Macros and lifecycle hooks: A composable lifecycle (onStart, onRequest, onParse, derive, onError, etc.) and user-defined macros make it possible to encapsulate cross-cutting concerns without the middleware-stack ergonomics tax.
• Node.js adapter: Since v1.1, the @elysiajs/node adapter lets you run the same Elysia code on Node.js if you cannot ship Bun in production, at a roughly 30–40% performance cost compared to native Bun.
• MIT licensed, fully open source: No telemetry, no paid tier, no enterprise gate — the entire framework, including Eden, plugins and integrations, lives on GitHub.

What Users Say About Elysia

Sentiment is unusually warm for a backend framework, especially among developers migrating from Express. On Dev.to, the most-read switchover post praises Elysia for "less boilerplate, cleaner code, and direct response returns instead of req/res/next" — a recurring theme. On Reddit's r/node and r/bun, the most upvoted threads highlight Eden Treaty as the killer feature: several developers describe it as "tRPC without the codegen step" and the closest thing TypeScript has to a Phoenix LiveView equivalent for type safety between client and server.

The recurring complaints are honest and worth weighing. The biggest one is the Bun lock-in: every comparison piece in 2026 — from Encore's Elysia-vs-Hono breakdown to PkgPulse's framework roundups — flags that Hono's portability across Node, Deno, Cloudflare Workers and AWS Lambda still makes it the safer multi-runtime pick. Hono's GitHub star count (~90k) is roughly 5× Elysia's, which means more StackOverflow answers, more community plugins and more tutorials when something goes wrong. A separate critique on Dev.to from a long-time user notes that Elysia's documentation is "friendly for newbies but lacks the depth a seasoned developer might crave," especially around plugin internals and advanced macro patterns.

Elysia Pricing

Elysia is fully open source under the MIT license. There is no paid tier, no usage cap, no enterprise upsell and no telemetry collected by the project. You self-host on Bun (or on Node.js via the official adapter) on any provider you like.

Plan	Price	Key Limits
Open Source (only tier)	$0 forever	Unlimited routes, requests, deployments. MIT license. Community support via Discord and GitHub Issues. Pay only your own infrastructure.

For comparison, equivalent typed-API stacks on managed runtimes (e.g., Vercel Functions + tRPC at scale, or Encore Cloud's hosted tier) start in the tens of dollars per month and scale into hundreds. Elysia + Bun on a $5 Hetzner box can comfortably handle most early-stage SaaS workloads.

Who Should Use Elysia?

Best for: Backend engineers and full-stack TypeScript teams who have already adopted Bun (or are greenfield enough to adopt it), small-to-mid SaaS teams who want one source of truth between server and client without a separate tRPC or OpenAPI codegen step, and performance-sensitive APIs (real-time, edge-adjacent, high-RPS endpoints) where every millisecond of framework overhead matters.

Not ideal for: Teams locked into Node.js LTS for compliance reasons, multi-runtime projects that need to deploy the same codebase to Cloudflare Workers, Deno Deploy and AWS Lambda (Hono is the better pick here), or large enterprise teams that prioritize community size, vendor support and the volume of available StackOverflow answers over raw DX.

Pros and Cons

Pros:

• Best-in-class end-to-end type safety on Bun via Eden Treaty — no codegen, no manual sync.
• Genuinely fast: 2.5M req/s in synthetic benchmarks, 33k req/s with real validation.
• MIT open source, no telemetry, no paid tier — entire framework is free forever.
• Official plugins for OpenAPI, JWT, CORS, OpenTelemetry and integrations with Drizzle, Prisma, Better Auth, React Email and most major frontend frameworks.
• Express-like chainable API is genuinely pleasant — adopters consistently report less boilerplate than Express, Fastify or Nest.

Cons:

• Bun-first design means production deployment essentially requires Bun (or accepting a 30–40% perf hit on the Node adapter).
• Smaller community than Hono — fewer StackOverflow answers, fewer third-party plugins.
• Documentation is approachable but thin on advanced internals (macros, plugin composition, JIT compiler details).
• Not yet a popular pick at large enterprises, so vendor support and case studies are limited.

Alternatives to Elysia

The two closest alternatives are Hono — broader runtime support across Node, Bun, Deno, Cloudflare Workers and AWS Lambda, with a much larger community but slightly less ergonomic type inference — and Encore, which adds infrastructure-as-code and a managed cloud control plane on top of a typed API surface. tRPC remains the dominant choice for Next.js teams who want typed RPC without changing backend frameworks. For raw Bun performance with no framework at all, the standard Bun.serve is always an option.

Verdict: Is Elysia Worth It?

Yes, with a clear caveat. If you have already committed to Bun, or you are starting a greenfield TypeScript backend in 2026, Elysia is the framework we would reach for first. The combination of Eden Treaty's typed client, TypeBox-driven validation, automatic OpenAPI, and Bun-native performance is unmatched in the current ecosystem and is the closest TypeScript has come to a Phoenix-like full-stack typed experience. The 86/100 rating reflects two real deductions: Bun lock-in (which limits its addressable market today) and a community still growing into Hono's footprint. For teams unwilling to bet on Bun, Hono remains the safer multi-runtime pick. For everyone else, Elysia is genuinely a joy to ship with.

Frequently Asked Questions

Is Elysia free?

Yes. Elysia is fully open source under the MIT license. There is no paid tier, no usage limit and no telemetry. You only pay for your own hosting.

What platforms does Elysia support?

Elysia is Bun-first and runs natively on Bun on Linux, macOS and Windows. A first-party @elysiajs/node adapter also lets you run the same code on Node.js, and integrations exist for Vercel, Netlify and Cloudflare Workers.

How does Elysia compare to Hono?

Elysia is faster on Bun and has the best end-to-end type safety in the ecosystem via Eden Treaty, but it is Bun-first. Hono runs on Node, Bun, Deno, Cloudflare Workers and AWS Lambda from one codebase and has a much larger community (~90k vs ~18k stars). Pick Elysia if you are committed to Bun and want the best DX; pick Hono if you need multi-runtime portability.

Is Elysia open source?

Yes. Elysia is MIT licensed and developed in the open at github.com/elysiajs/elysia.

Can I use Elysia in production?

Yes — Elysia has been production-stable since the 1.0 release and is at v1.4.28 as of May 2026, with active maintenance and a growing roster of companies using it for internal APIs, edge functions and SaaS backends. The recommended runtime is Bun for full performance.