Encore.ts vs Hono vs Elysia: Speed 2026

TL;DR

Encore.ts makes a bold claim: a Rust-powered runtime delivering 9x the throughput of Express and, in its own benchmarks, 3x faster than Hono and Elysia. The reality is more nuanced — Elysia 1.4+ on Bun has closed the gap and, in some benchmarks, now outperforms Encore. But Encore.ts isn't just a fast HTTP router: it's an opinionated full-stack TypeScript backend with automatic infrastructure, distributed tracing, and a structured service model. The right choice depends on whether you want raw throughput or a complete backend platform.

Key Takeaways

• Encore.ts Rust runtime — offloads I/O, request parsing, and DB queries to a Rust layer, freeing Node.js for pure business logic
• 9x faster than Express — consistent across benchmarks with and without validation
• Elysia 1.4 fights back — with Bun runtime, Elysia now matches or exceeds Encore in raw req/s in some published benchmarks
• Hono is the multi-runtime choice — runs on Node.js, Bun, Deno, Cloudflare Workers, and AWS Lambda
• Encore.ts is more than a framework — automatic cloud infrastructure, Encore Cloud, and distributed tracing are bundled
• Benchmark caveats — synthetic benchmarks diverge from real-world DB-heavy workloads where differences shrink

The Frameworks

Encore.ts

Encore.ts (encore.dev) takes a fundamentally different approach to performance: instead of optimizing the JavaScript layer, it replaces it for I/O-heavy work with a Rust runtime.

// Encore.ts uses a service-oriented model, not just middleware
import { api } from "encore.dev/api";
import { SQLDatabase } from "encore.dev/storage/sqldb";

const db = new SQLDatabase("users", {
  migrations: "./migrations",
});

// This endpoint is automatically traced, type-safe, and validated
export const getUser = api(
  { expose: true, method: "GET", path: "/users/:id" },
  async ({ id }: { id: string }) => {
    const user = await db.queryRow`SELECT * FROM users WHERE id = ${id}`;
    return { user };
  }
);

The Rust runtime handles: HTTP parsing, TLS, request routing, schema validation, database connection pooling, and distributed tracing. The Node.js event loop only runs your TypeScript business logic.

GitHub: ~14K stars | npm: encore.dev

Hono

Hono (hono.dev) is a lightweight Web Standards-based router that runs on any JavaScript runtime. Its tagline: "Fast, lightweight, built on Web Standards. Support for any JavaScript runtime."

import { Hono } from "hono";
import { zValidator } from "@hono/zod-validator";
import { z } from "zod";

const app = new Hono();

app.get(
  "/users/:id",
  zValidator("param", z.object({ id: z.string() })),
  async (c) => {
    const { id } = c.req.valid("param");
    return c.json({ id, name: "Alice" });
  }
);

export default app;
// Same code runs on: Node.js, Bun, Deno, Cloudflare Workers, AWS Lambda Edge

GitHub: 22K+ stars | npm: hono

Elysia

Elysia (elysiajs.com) is built specifically for Bun. It leverages Bun's native I/O and uses macro-based type inference for zero-overhead schema validation via Eden (its type-safe client).

import { Elysia, t } from "elysia";

const app = new Elysia()
  .get("/users/:id", ({ params: { id } }) => ({
    id,
    name: "Alice"
  }), {
    params: t.Object({
      id: t.String()
    })
  })
  .listen(3000);

// Eden provides end-to-end type safety — no codegen needed
export type App = typeof app;

GitHub: 11K stars | npm: elysia

Fastify

Fastify (fastify.dev) is the established Node.js performance leader — battle-tested, massive plugin ecosystem, 2-3x faster than Express.

import Fastify from "fastify";
import { Type } from "@sinclair/typebox";

const fastify = Fastify({ logger: true });

fastify.get<{ Params: { id: string } }>(
  "/users/:id",
  {
    schema: {
      params: Type.Object({ id: Type.String() }),
    },
  },
  async (request) => {
    return { id: request.params.id, name: "Alice" };
  }
);

fastify.listen({ port: 3000 });

GitHub: 32K stars | npm: fastify

Benchmark Data (2026)

Published Benchmarks: Encore vs Elysia vs Hono vs Fastify

From the Encore team's ts-benchmarks repo (github.com/encoredev/ts-benchmarks), using 150 concurrent workers, 10s runs, oha load tester:

Without validation (routing only):

With schema validation:

Elysia's Counter-Benchmark

The Elysia team published their own benchmark (elysiajs.com/blog/elysia-v-encore) showing that after 1.5 years of development, Elysia now matches or exceeds Encore on Bun in the same benchmark conditions.

The divergence comes from methodology: Encore benchmarks often use Node.js for Encore (where its Rust runtime shines) while Elysia is tested on Bun (its native target). When both run on Node.js, Encore wins. When both run on Bun, the gap disappears or reverses.

Real-World Context

Synthetic benchmarks measure routing throughput. Real applications are dominated by database I/O and business logic, where these differences shrink:

Architectural Differences: Beyond Throughput

Encore.ts: Backend Platform

Encore.ts is opinionated — it's not just a router, it's a backend framework with infrastructure:

Auto-provisioned infrastructure:

// Encore auto-creates the database, queue, and cache based on your code
import { SQLDatabase } from "encore.dev/storage/sqldb";
import { PubSub } from "encore.dev/pubsub";
import { CacheCluster } from "encore.dev/cache";

const db = new SQLDatabase("mydb", { migrations: "./migrations" });
const events = new PubSub.Topic("user-events");
const cache = new CacheCluster("sessions", { eviction: "allkeys-lru" });

Encore provisions these resources in local dev (via Docker), staging, and production cloud (Encore Cloud, AWS, or GCP) — all from the same TypeScript declarations.

Distributed tracing built-in: Every API call, database query, and pub/sub message is traced automatically in Encore's dashboard.

Hono: Multi-Runtime Portability

Hono's superpower is environment portability:

// The same Hono app runs everywhere:
import { Hono } from "hono";
import { handle } from "hono/aws-lambda";

const app = new Hono();
app.get("/", (c) => c.text("Hello!"));

// Node.js
import { serve } from "@hono/node-server";
serve(app);

// Cloudflare Workers
export default app;

// AWS Lambda
export const handler = handle(app);

// Bun
Bun.serve({ fetch: app.fetch });

No other framework matches this runtime portability. For teams deploying to edge networks, serverless, and traditional servers from the same codebase, Hono is the pragmatic choice.

Elysia: Bun-Native DX

Elysia's Eden plugin provides end-to-end type safety between server and client without a code generation step:

// Server (Elysia)
const app = new Elysia()
  .get("/users/:id", ({ params }) => ({
    id: params.id,
    name: "Alice"
  }));

// Client (Eden) — fully type-safe, no codegen
import { treaty } from "@elysiajs/eden";
const client = treaty<typeof app>("localhost:3000");

const { data, error } = await client.users({ id: "1" }).get();
// data is typed as { id: string, name: string }

This DX is comparable to tRPC but without the query/mutation distinction — it's just HTTP with types.

When to Choose Each

Choose Encore.ts when:

• You're building a new backend service and want batteries-included infrastructure
• You need distributed tracing and observability without configuring OpenTelemetry manually
• Your team wants to deploy to multiple cloud providers without learning Terraform
• You're on Node.js (not Bun) and want the best performance

Choose Hono when:

• You need to run on edge/serverless (Cloudflare Workers, Vercel Edge, AWS Lambda@Edge)
• You want multi-runtime portability — same code deploys anywhere
• You prefer a minimal, Express-like API with modern TypeScript support
• Bundle size matters (Hono core is tiny)

Choose Elysia when:

• You're all-in on Bun and want the best DX
• You need end-to-end type safety without codegen (Eden)
• Your team prioritizes raw performance on Bun
• You're comfortable adopting two cutting-edge technologies simultaneously (Bun + Elysia)

Choose Fastify when:

• You need a battle-tested Node.js framework with a proven plugin ecosystem
• You're migrating from Express and want a familiar model with better performance
• Your team is risk-averse about frameworks in active beta development

Quick Performance Summary

Node.js only:
  Express: ████░░░░░░░░░░ (baseline)
  Fastify: ████████████░░ (~2-3x Express)
  Encore.ts: ██████████████ (~9x Express, Rust runtime)

With Bun:
  Hono: ████████████░░ (~6x Express baseline)
  Elysia: ██████████████ (~7-8x Express baseline, varies by test)

The "9x faster than Express" claim is accurate for Encore in Node.js environments. On Bun, Elysia and Hono close the gap significantly.

Observability and Production Monitoring

Production backend services require observability beyond raw throughput benchmarks, and the frameworks diverge significantly here. Encore.ts provides the most complete built-in observability: every API call, database query, pub/sub message, and cache operation is traced automatically in Encore's developer dashboard and in your cloud provider's tracing system. You do not configure OpenTelemetry, set up a Jaeger instance, or instrument individual database calls. This zero-configuration tracing is Encore's strongest differentiator for teams that have experienced the operational cost of retrofitting observability into existing services.

Type Safety and Schema Validation Architecture

The four frameworks take fundamentally different approaches to request validation and type safety, and these differences affect both developer experience and runtime behavior. Encore.ts generates the request and response schema from your TypeScript types at build time — when you define a handler function that accepts { id: string }, Encore's Rust runtime validates incoming requests against that schema before the TypeScript handler ever runs. This means validation errors are caught at the infrastructure layer, not in your business logic, and the validation cost is borne by Rust, not the JavaScript event loop.

Hono delegates validation to middleware libraries like Zod or Valibot via adapters such as @hono/zod-validator. This is more flexible — you can choose your validation library and compose validators per-route — but it means validation runs in the JavaScript layer. The zValidator middleware injects typed request context via Hono's generics system, so c.req.valid('json') returns the Zod-parsed and typed object, not a raw unknown. The Hono RPC mode (@hono/rpc) additionally generates a type-safe client from your route definitions without a code generation step, similar to tRPC but using Hono's Web Standards-compatible primitives.

Elysia's type inference system is its most distinctive feature. The t type builders (TypeBox under the hood) create both the runtime validator and the TypeScript type simultaneously — no separate schema-to-type step, no codegen. Elysia's macro system computes these types at the TypeScript compiler level, which means the Eden client gets accurate types with zero runtime overhead. Fastify's approach (TypeBox for JSON Schema validation + TypeScript generics for handler types) is the most established pattern but requires the most boilerplate — you define the JSON Schema for validation and separately specify the TypeScript generic for type inference, and you must keep them in sync manually.

Methodology

• Sources: encoredev/ts-benchmarks (GitHub), encore.dev/blog/event-loops (Rust event loop post), elysiajs.com/blog/elysia-v-encore (Elysia counter-benchmark), betterstack.com/community/guides/scaling-nodejs/fastify-vs-express-vs-hono/, hono.dev/docs/concepts/benchmarks, encore.dev/articles/best-typescript-backend-frameworks-2026
• Benchmarks: 150 concurrent workers, 10s runs, oha load tester
• Data as of: March 2026

Comparing TypeScript API frameworks? See also Hono vs Elysia 2026: The Bun-Era Backend Frameworks and Hono RPC vs tRPC vs ts-rest 2026.

Using Encore.ts for cloud-native backends? Compare Encore vs Nitric vs Shuttle 2026.