Bunweb: A Minimalist, Koa-Style Web Framework Built for Bun

When I began building backend applications with Bun, the appeal was obvious: its speed, native TypeScript support, and elegant serve() API made it a tempting alternative to Node. As the projects grew, though, I missed the expressiveness I was used to in frameworks like Koa, which made building larger services complex and bug-prone.

That gap is what ultimately led me to build bunweb, a tiny, expressive web framework for Bun inspired by Koa, but built with zero external dependencies, and Bun-native.

The Problem: Bun Is Fast, But Sometimes Too Bare

Bun’s native serve() API is great for performance:

Bun.serve({
  fetch(req) {
    return new Response("Hello");
  }
});

But when your app grows, a few limitations become hard to ignore. Want logging → body parsing → auth → route handler → error handling? You must manually compose logic inside one fetch() function and hope you don’t accidentally skip something.

You will likely end up writing your own router to parse paths, extract params, branch logic, etc.

For example, implementing a simple GET endpoint for fetching a user could require a verbose solution:

Bun.serve({
  port: 3000,
  async fetch(req) {
    const url = new URL(req.url);

    if (req.method !== "GET") {
      return new Response("Method Not Allowed", { status: 405 });
    }

    const parts = url.pathname.split("/").filter(Boolean);
    if (parts[0] !== "users" || parts.length !== 2) {
      return new Response("Not Found", { status: 404 });
    }

    const id = parts[1];
    const user = await db.find(id);

    if (!user) {
      return new Response(
        JSON.stringify({ error: "User not found" }),
        { status: 404 }
      );
    }

    return new Response(
      JSON.stringify({ user }),
      { status: 200 }
    );
  }
});

The Solution: bunweb

Bunweb brings a clean, familiar API to Bun:

• Koa-style async middleware pipeline
• Lightweight router with params and method helpers
• Declarative ctx.body, ctx.status, andctx.set for setting the response body, status code, and headers.
• Zero dependencies, tiny footprint, and Bun-friendly
• First-class TypeScript support

With Bunweb, we can solve the same problem above with:

import { server } from "bunweb";

const app = server();

app.get("/users/:id", async (ctx, next) => {
  const user = await db.find(ctx.params.id);
  if (!user) {
    ctx.status = 404;
    ctx.body = { error: "User not found" };
  } else {
    ctx.body = { user };
  }
  await next();
});

app.listen(3000);

Limitations and How bunweb Differs from Koa

Although bunweb borrows inspiration from Koa, Koa is far more mature and feature-rich, while bunweb is minimal and still very much an experiment.

In addition, Koa takes a modular approach: the main koa package provides the core framework, while routing is handled separately through packages like @koa/router. Bunweb, however, keeps things unified, with the server and router living in a single bunwebpackage.

Their execution models also diverge: Koa runs middlewares strictly in registration order, while bunwebuse() middlewares always run before method-specific handlers like get() or post().

Finally, bunweb is built specifically for Bun and uses native Web Request and Response objects , whereas Koa wraps Node’s lower-level primitives to offer a richer abstraction.

Final Thoughts

Bunweb is still a small experimental framework exploring what a Koa-like API might look like in Bun’s runtime, so it should be used with caution in production. With that said, there’s plenty of room for it to grow, and contributions from Bun enthusiasts are more than welcome! Push requests and issues can be sent to:

👉 GitHub: https://github.com/abrantesarthur/bunweb

Happy coding!