0http — Zero Friction HTTP Framework for Node.js

Features

Why 0http?

A framework designed for developers who want speed without ceremony.

⚡

Blazing Fast

One of the fastest Node.js web frameworks. The new trie router resolves static routes in ~80ns and keeps dynamic routes flat as your API grows — no regex per route, no cache to size.

🎛

Highly Configurable

Swap routers, servers, and customize every behavior. You're in full control of the stack.

🔗

Middleware Engine

Express-like chain with full async/await support. Global or route-specific — your call.

⚙

Minimal, Fast, Secure

Three runtime dependencies. Zero bloat. Every line is optimized for raw throughput — smaller surface, fewer vectors, more speed.

🧩

Nested Routing

Modular architecture with nested routers, on both engines. Mount prefixes are stripped from the path only, so a query string can never become a nested route.

🛡

Production Ready

Safe-by-default error handler, prototype pollution protection, and secure routing. Built for the real world.

Architecture

Core Capabilities

Everything you need, nothing you don't.

1. Pluggable Routers

0http lets you define the router implementation you prefer. Three engines are supported out of the box.

Trie Router (New in v5.2)

A dependency-free segment-trie engine with the same API, middleware chain, nested routers and error containment as the default router. Static routes resolve through a compile-on-demand table in constant time; dynamic routes walk the trie with no regex per route, so lookup cost stays flat whether you register 5 routes or 500.

~80ns static lookups (2× faster than sequential), 175ns param lookups, flat at 500 routes where sequential climbs past 1µs
Safer defaults: case-sensitive matching, literal static segments, null-prototype params, no request-keyed cache to exhaust
Patterns: /static, /:param, /:param?, /:name.ext, trailing /* and RegExp with named groups
Opt in with require('0http/lib/router/trie')()

Sequential Router (Default)

Extended trouter with middleware, nested routers, and regex matching. Uses internal LRU cache for blazing-fast repeated lookups.

Supports GET, HEAD, PATCH, OPTIONS, CONNECT, DELETE, TRACE, POST, PUT
Configurable cache size — 0 to disable, negative for unlimited

Find-My-Way Router

Integration with find-my-way, a radix-tree router for maximum static path performance.

Best for static paths and high throughput without regex overhead
Does not support all middleware features of the sequential router

2. Middleware Engine

Optimized for both performance and flexibility. Global middleware, route-level middleware, and full async/await support — all in a minimal execution loop.

3. Nested Routers

Organize your application with modular nested routers. 0http optimizes static nested routes with direct slicing — zero regex overhead where it counts.

4. Custom Servers

Server-agnostic. Use standard http.Server, https.Server, or your own implementation. 0http just needs an event emitter.

Install

Get Started

One command and you're running.

$ npm install 0http Copied!

Examples

Quick Start

Common patterns to get you moving fast.

trie-router.js

const trie = require('0http/lib/router/trie')
const { router, server } = require('0http')({
  router: trie()
})

router.get('/users/:id', (req, res) => {
  res.end(req.params.id)
})
router.get('/files/*', (req, res) => {
  res.end(req.params['*'])
})

server.listen(3000)

basic-server.js

const { router, server } = require('0http')()

router.get('/hello', (req, res) => {
  res.end('Hello World!')
})

server.listen(3000)

json-api.js

router.get('/api/users', (req, res) => {
  res.setHeader('Content-Type', 'application/json')
  res.end(JSON.stringify({
    users: [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]
  }))
})

middleware.js

// Global logger
router.use((req, res, next) => {
  console.log(`${req.method} ${req.url}`)
  return next()
})

// Route-level auth
router.get('/admin', auth, (req, res) => {
  res.end('Welcome, admin')
})

async-handler.js

router.get('/users/:id', async (req, res) => {
  const user = await db.findById(req.params.id)
  if (!user) {
    res.statusCode = 404
    return res.end('Not found')
  }
  res.setHeader('Content-Type', 'application/json')
  res.end(JSON.stringify(user))
})

nested-routers.js

const { router: api } = require('0http')()

api.get('/users', getUsers)
api.post('/users', createUser)

// Mount at /api
router.use('/api', api)

error-handler.js

const { router, server } = require('0http')({
  errorHandler: (err, req, res) => {
    console.error(err)
    res.statusCode = 500
    res.end('Internal Server Error')
  }
})

router.get('/broken', () => {
  throw new Error('Oops!')
})

Configure

Configuration

Pass an options object to zero(config) — everything is optional.

Option	Description	Default
router	Custom router instance	sequential()
server	Custom server instance	http.createServer()
defaultRoute	Handler for 404 Not Found	404 + res.end()
errorHandler	Global error handler	Safe-by-default (v5.0+)
prioRequestsProcessing	Use setImmediate for priority processing	true
cacheSize	Sequential router: LRU cache size (0=off, <0=unlimited)	−1
caseSensitive	Trie router: match paths case-sensitively	true
ignoreTrailingSlash	Trie router: treat `/users/` and `/users` alike	true

Zero friction HTTP framework for Node.js