Compare Elysia
Stacks vs Elysia

Both are Bun-first. One is a router, one is an application framework.

Elysia is the strongest argument for Bun on the server: schema-validated routes, inferred types, an Eden client with no code generation, and throughput at the top of every benchmark. Stacks shares the runtime bet and answers a different question, which is everything you need once the router is chosen.

See what ships All comparisons

What Elysia is.

In its own terms, not ours.

Elysia is built for Bun specifically and uses that to do things portable frameworks cannot, including ahead-of-time route compilation. TypeBox schemas validate requests and produce types, plugins compose cleanly, and Eden gives a fully typed client. For a high-performance Bun API it is an excellent choice.

Where each one wins.

Same amount of room on both sides, on purpose.

Pick Elysia for

  • Raw performance

    Elysia is faster at the routing layer than a full framework will be, and if requests per second per core is your metric, it wins.

  • Eden

    End-to-end types with no generation step is a smoother developer experience than OpenAPI plus a generated client.

  • Small surface

    Fewer concepts to learn, and nothing you do not use.

  • Plugin composition

    The plugin model is clean and makes sharing behaviour between services straightforward.

Pick Stacks for

  • Batteries, not building blocks

    ORM, migrations, auth, RBAC, queues, mail, storage, search, realtime, CMS, commerce, and an admin dashboard.

  • Views and assets

    A front end in the same project, server-rendered, with a component model and styling.

  • Structure that survives growth

    Conventions for where things live, so the tenth feature looks like the first.

  • Deploy and operations

    Infrastructure from config, a dashboard for jobs and mail, and CI that ships on push.

Side by side.

The dimensions teams actually decide on.

Dimension Stacks Elysia
Scope Full application framework HTTP framework
Runtime Bun Bun
Validation On model attributes TypeBox schemas per route
Client types Generated client from OpenAPI Eden, inferred
Data layer Included Choose your own
Background work Included Choose your own
Views STX Add a template engine
Raw throughput Good, with a framework in the path Best in class

If you did move.

What ports cleanly, what does not, and where to start.

Same runtime, so no rewrite of the primitives

Bun APIs, native SQLite, and package resolution behave the same on both sides.

Schemas become model validation

TypeBox route schemas move onto attributes, where the factory and the generated API also use them.

Eden consumers switch clients

Clients move from Eden to the generated REST client, which is the main piece of work.

The verdict.

Both answers are real. Most teams already know which paragraph is theirs.

Choose Elysia when

The service is an API, throughput is the requirement, and you want the thinnest possible layer over Bun.

Choose Stacks when

You want the same runtime with the rest of the application already written and typed together.

The frameworks that usually come up in the same conversation.

Stacks vs Hono

A tiny, fast, edge-first router. Stacks is the application you would build on top of one.

Stacks vs Express and Fastify

Minimal HTTP layers. Everything above the router is a decision you make and maintain.

Stacks vs NestJS

Structured TypeScript backends with dependency injection. Stacks trades DI for conventions.