bunWay

Roadmap & Contributions ​

bunway is a community-powered project building the Bun-native, Express-compatible web toolkit we want to use. This page shows what's shipped and what's next.

Philosophy ​

  • Express-compatible – same (req, res, next) signature and middleware patterns you know
  • Bun-native – built on Bun's Fetch primitives, no Node polyfills
  • Batteries included – one package for routing, middleware, sessions, security, observability
  • Community-led – we build what developers actually need
Phase 0 · Complete

Core MVP

Express-compatible foundation with Bun-native primitives.

  • BunRequest, BunResponse with Express-style APIs
  • Express-compatible (req, res, next) handler signature
  • Router verbs, params, sub-routers, middleware, 404 fallback
  • bunway() factory + app.listen()
  • Built-ins: errorHandler, cors, json, urlencoded, text
  • Comprehensive Bun test suite
Phase 1 · Complete

HTTP niceties & DX

Polished developer experience with essential middleware.

  • cookieParser() – parse/set cookies, signed cookies
  • helmet() – security headers
  • compression() – gzip/br/deflate compression
  • serveStatic() – static file serving with cache controls
Phase 2 · Complete

Sessions & auth

Stateful applications with sessions and authentication.

  • session() – session middleware with Memory/File stores
  • csrf() – CSRF protection (double-submit cookie pattern)
Phase 3 · Complete

Streaming & uploads

Advanced request handling for modern applications.

  • upload() – multipart/form-data with memory & disk storage
  • sse() – Server-Sent Events with heartbeat support
  • WebSocket routing (types exported)
Phase 4 · Complete

QoS & protection

Production-ready quality of service features.

  • rateLimit() – rate limiting with Memory store
  • timeout() – request timeout with configurable response
  • hpp() – HTTP Parameter Pollution protection
Phase 5 · Complete

Observability & DX polish

Visibility and developer utilities for production apps.

  • logger() – morgan-style request logging with color support
  • requestId() – request ID propagation
  • responseTime() – response time header
  • methodOverride() – HTTP method override for legacy clients
  • favicon() – efficient favicon serving with ETag caching
  • validate() – request validation middleware
Phase 6 · In Progress

Middleware hardening & 100% parity

Every middleware is working — now we're completing them to full parity with their Express counterparts and hardening with comprehensive test coverage.

  • Full test suites for all 26 middleware
  • 100% option parity with Express counterpart packages
  • Edge case coverage and stress testing
  • Pluggable stores for rate-limit (Redis, etc.)
  • Byte range support in serveStatic
  • IETF standard rate limit headers (draft-6)
  • Metrics endpoint (Prometheus)
Phase 7 · Upcoming

Performance

Now that the DX layer is complete, the focus shifts to making bunway as fast as possible.

  • Benchmark suite — establish baseline req/sec numbers
  • Streaming compression (avoid buffering full responses)
  • Header lookup optimisations
  • Middleware chain allocation reduction
  • Cookie parser — hand-rolled for speed

Where we need help ​

All 26 middleware are working. Here's what's left — every item below is an open invitation:

  • Test coverage – pick any middleware that interests you and write its test suite
  • Option parity – compare a middleware against its Express counterpart, find a missing option, open an issue or send a PR
  • Pluggable stores – rateLimit uses an in-memory store; Redis/custom adapters are a great contribution
  • Performance – benchmarks, profiling, hot-path optimisations
  • Docs – usage examples, migration guides, recipe pages

If something is missing or broken, open an issue. If you know how to fix it, open a PR. We review fast.

How to contribute ​

Getting started

Pick something from the list above, open an issue to discuss the approach, and build on Bun's native APIs.

  1. Pick a task – anything in Phase 6 or 7, or something you hit in your own project
  2. Open an issue – describe the gap, expected vs actual behaviour, and your proposed approach
  3. Build it – use Bun's primitives, keep it lean, match Express API shape
  4. Test & document – Bun tests + update the relevant docs page
  5. Submit a PR – we'll review and iterate together

Development workflow ​

bash
bun install           # Install deps
bun run test          # Run test suite
bun run typecheck     # TypeScript check
bun run format        # Prettier formatting
bun run docs:dev      # VitePress docs (development)

bun run prepare:dist builds the publishable package.

Community promise ​

bunway is built for developers who love Express patterns but want Bun's speed. The DX foundation is done — now we're making it bulletproof and fast.

Jump in. Share ideas. Help us build the best Express-compatible framework for Bun.