Framework Comparison
Side-by-side code comparison of NextRush, Express, Fastify, Hono, and Koa — routing, middleware, error handling, and TypeScript support.
How NextRush compares to popular Node.js frameworks — not only speed, but how you write code.
Looking for benchmarks?
This page compares code patterns and architecture. For raw performance numbers, see Benchmarks.
At a Glance
| Feature | NextRush | Express | Fastify | Hono | Koa |
|---|---|---|---|---|---|
| TypeScript | First-class (strict) | Bolt-on (@types) | Built-in | Built-in | Bolt-on (@types) |
| Runtime deps | 0 | 31 | 15 | 0 | 24 |
| Multi-runtime | Node, Bun, Deno, Edge | Node only | Node only | Node, Bun, Deno, Edge | Node only |
| Context API | Single ctx object | req + res + next | request + reply | Single c object | Single ctx object |
| Middleware model | Koa-style onion | Linear chain | Hooks + lifecycle | Koa-style onion | Onion model |
| Built-in DI | Yes (@nextrush/di) | No | No | No | No |
| Decorators | Yes (@Controller, @Get) | No | Via plugins | No | No |
| Extensibility | Extension + middleware | app.use() | Encapsulated plugins | Middleware only | app.use() |
| Routing | Segment trie (O(k)) | Linear scan (O(n)) | Radix tree (O(k)) | Radix tree (O(k)) | Via koa-router |
NextRush's extensibility model is layered: app.use() middleware for the vast majority of
cases, plain-function registrars (e.g. registerControllers) for wiring subsystems, and the
rare, long-lived Extension (via app.extend() + await app.ready()) for app-scoped services
like an event bus. There is no Plugin interface or plugin registration API.
Hello World
The same endpoint in every framework.
import { createApp, createRouter, listen } from 'nextrush';
const app = createApp();
const router = createRouter();
router.get('/', (ctx) => ctx.json({ message: 'Hello World' }));
app.route('/', router);
await listen(app, 8080);Middleware
How each framework composes middleware — logging, auth, and error handling.
Koa-style onion model. Code before ctx.next() runs on the way in, code after runs on the way out.
// Timing middleware
app.use(async (ctx) => {
const start = Date.now();
await ctx.next();
ctx.set('X-Response-Time', `${Date.now() - start}ms`);
});
// Auth middleware
app.use(async (ctx) => {
const token = ctx.get('authorization');
if (!token) throw new UnauthorizedError('Missing token');
ctx.state.user = verifyToken(token);
await ctx.next();
});Key difference: NextRush and Koa share the onion model — you write both "before" and "after" logic in one function. Express uses linear chains with separate error middleware. Fastify uses lifecycle hooks.
Error Handling
Typed error classes with automatic status codes. Thrown errors become JSON responses.
import { NotFoundError, ValidationError } from '@nextrush/errors';
router.get('/users/:id', (ctx) => {
const user = db.find(ctx.params.id);
if (!user) throw new NotFoundError('User not found');
ctx.json(user);
});
// Custom error handler
app.setErrorHandler((error, ctx) => {
ctx.status = error.status ?? 500;
ctx.json({
error: error.message,
code: error.code,
});
});TypeScript Support
| Aspect | NextRush | Express | Fastify |
|---|---|---|---|
| Source language | TypeScript | JavaScript | TypeScript |
| Types included | Yes (strict mode) | No — install @types/express | Yes |
| Route param inference | Via generics on ctx | Manual casting required | Via JSON Schema |
| Body type safety | Transform decorators (Zod, etc.) | None built-in | JSON Schema validation |
| Strict mode | Enforced — zero any | Optional | Optional |
// NextRush — types flow naturally
router.get('/users/:id', (ctx) => {
const id = ctx.params.id; // string (typed)
const page = ctx.query.page; // string | undefined (typed)
ctx.json({ id, page }); // return type checked
});When to Choose What
| Your priority | Likely fit | Notes |
|---|---|---|
| Raw throughput (Node.js only) | Fastify | AOT JSON serialization, mature radix tree |
| Multi-runtime (Bun, Deno, Edge) | NextRush or Hono | Compare adapters and deploy targets |
| Strict TypeScript + small core deps | NextRush | Core packages avoid extra runtime dependencies |
| Large ecosystem + community | Express | Broad middleware ecosystem and tutorials |
| Class-based + DI | NextRush | Optional decorators and DI in the same stack |
| Minimal learning curve | Koa or Express | Familiar patterns and documentation |
| Mixed functional + class routes | NextRush | Both styles can coexist in one app |
Migration Paths
Ready to switch? Follow the step-by-step guides:
Session position
NextRush ships no session/authentication/JWT package today. This page states the framework's committed position — what applications own now, what the framework will own, and why the gap is documented rather than silently closed.
Dependency Injection Internals
How @nextrush/di wraps tsyringe — the container adapter, scope mapping, circular dependency detection, and the tsyringe coupling boundary.