Skip to main content

Muzu

High-Performance TypeScript HTTP Framework

Zero dependencies. Decorator-based API. Built-in validation & Swagger support.

Get Started →Quick Start
import { MuzuServer, Controller, Get } from 'muzu';

@Controller('/api')
class UserController {
  @Get('/users')
  getUsers() {
    return { users: [] };
  }
}

new MuzuServer().listen(3000);

Core Features

Everything you need to build production-ready APIs, with exceptional performance.

Ultra Fast Performance

Optimized radix tree routing with O(k) lookup complexity. Build-time compilation of validators and middleware composition eliminates runtime overhead. Async detection and conditional body parsing ensure minimal processing per request.

Zero Dependencies

Only requires reflect-metadata. All features including validators, HTTP status codes, body parsing, and routing are implemented in-house. No bloated external libraries - resulting in faster installs and smaller bundle sizes.

Decorator-Based API

Write clean, declarative code with TypeScript decorators. Define routes, validation rules, and middleware with simple annotations. Full type safety ensures you catch errors at compile time, not runtime.

Built-in Request Validation

Powerful validation system with zero external dependencies. Validators are compiled to optimized inline code at startup. Supports nested objects, arrays, custom rules, and provides detailed error messages automatically.

OpenAPI/Swagger Support

Automatically generate OpenAPI 3.0 documentation from your decorators. Interactive Swagger UI included out of the box. Document your APIs with simple annotations - no separate config files needed.

Smart Compilation

Routes, validators, and middleware are compiled at application startup. Middleware arrays are composed into single functions. Query params detection and path parsers are pre-compiled for maximum runtime efficiency.

Why Choose Muzu?

Built from the ground up for performance, developer experience, and production reliability.

⚡ Performance First

Every decision in Muzu prioritizes runtime performance. Routes are stored in a radix tree for O(k) lookup. Validators compile to inline code. Middleware chains compose into single functions. The result? 50-70% faster routing than traditional approaches with only ~5% validation overhead.

🎯 Type-Safe by Design

Full TypeScript support with excellent type inference. Decorators provide metadata at build time, enabling compile-time error detection. Your IDE knows exactly what types are available at every step, reducing bugs before they reach production.

📦 Minimal Footprint

With only one dependency (reflect-metadata), Muzu keeps your node_modules lean. No class-validator, no http-status packages, no utility libraries. Everything you need is built-in and optimized specifically for the framework's use case.

🚀 Production Ready

Comprehensive exception handling with custom error types. Automatic request validation with detailed error messages. Built-in Swagger documentation generation. Middleware support for authentication, logging, and more. Everything you need to ship to production.