Home

NextRush

NextRush is a TypeScript web framework built to eliminate accidental complexity from backend development. Applications get a small, explicit core, a runtime-independent execution model, and a class-based layer on top for teams that prefer declarative APIs — with no framework lock-in in either direction.

v4 is current — ESM-only, Node ≥ 22, TypeScript 5.x. See Getting Started to start a server in under a minute.

What NextRush looks like

Two layers, one core. Functional — small and explicit:

import { createApp, listen } from 'nextrush';

const app = createApp();

app.get('/hello/:name', (ctx) => {
  ctx.body = { message: `Hello, ${ctx.params.name}!` };
});

await listen(app, 8080);

Handlers write through the Context — no returned Response objects, no hidden global state.

Class-based — module-first for larger apps that prefer controllers and DI. Declare a feature as a @Module, compose features into an AppModule, and registerModule wires the whole graph:

import { createApp, listen } from 'nextrush';
import { Controller, Get, Module, registerModule } from 'nextrush/class';

@Controller('/users')
class UsersController {
  @Get()
  list() { return [{ id: 1, name: 'Ada' }]; }
}

@Module({ controllers: [UsersController] })
class UsersModule {}

@Module({ imports: [UsersModule] })
class AppModule {}

const app = createApp();
await registerModule(app, AppModule);
await listen(app, 8080);

Same app, same runtime — the class layer just declares routes and dependencies instead of wiring them by hand. See Controllers & Decorators and Modules.

Why NextRush

• One obvious golden path — copy-paste-runnable, working out of the box.
• Runtime independent — the same app runs on Node, Bun, Deno, and edge runtimes via adapters; core speaks only Web-standard primitives.
• Small core, two layers — a functional core (routes, middleware, context) and an optional class runtime (controllers, DI, modules) that is a registrar on top of the core, not a rewrite.
• Zero-dependency core — the framework owns complexity; applications stay lean and fast. See Performance for the benchmark scoreboard.
• Excellent DX — strict types, actionable errors, autocomplete-friendly APIs, testing built around real objects, not mocks.

Explore

• Getting Started — install, scaffold, first server
• Core Concepts — application, context, handlers, middleware
• Routing — the segment-trie router, params, mounting
• Middleware — composition and ordering
• Error Handling — error hierarchy and handlers
• Controllers & Decorators — the class-based layer
• Dependency Injection — the container and scopes
• Request Scope — per-request services and scope bubbling
• Modules — an AppModule composing feature modules
• Lifecycle — onInit / onShutdown boot and shutdown hooks
• Discovery — auto-discovering controllers
• Diagnostics — introspection report for your routes and providers
• Extensions — long-lived app-scoped services
• Streaming — text, SSE, and NDJSON responses
• Request Lifecycle — how a request flows through the pipeline
• Adapters — runtime abstraction and parity
• Testing — unit, integration, and E2E patterns
• Performance — benchmarks and tuning
• Packages — package index and exports
• Architecture — monorepo design and invariants
• Contributing — development setup and conventions
• Changelog — release history and upgrade notes

External

• Documentation site — full API reference, guides, and tutorials
• Repository
• npm