DEV Community: Little Prince

PrinceJS vs Hono vs Express vs Elysia: Benchmarking the Fastest Bun Frameworks in 2025

Little Prince — Fri, 20 Mar 2026 18:00:00 +0000

If you're building a backend with Bun in 2025 and you care about raw performance, you've probably looked at Hono and Elysia. They're fast. But there's a new framework sitting comfortably in the top three — and it was built by a 13-year-old from Nigeria.

That framework is PrinceJS.

This post breaks down the real benchmark numbers, what they mean for your application, and why PrinceJS might be the right choice even though it isn't the fastest framework in the list.

The Real Benchmark Numbers

All benchmarks were run with oha -c 100 -z 30s on Windows 10. Same machine, same conditions, no tricks.

Framework	Req/s	Total Requests
Elysia	25,312	759k
Hono	22,124	664k
PrinceJS	21,748	653k
Express	9,325	280k

PrinceJS hits 21,748 requests per second — third globally among Bun frameworks and 2.3x faster than Express.

Elysia leads the pack, Hono is second, and PrinceJS is right behind at third. The gap between Hono and PrinceJS is about 1.7%. The gap between PrinceJS and Express is enormous.

Why PrinceJS is Competitive Despite Being Third

Raw req/s isn't the only metric that matters. Here's the full picture:

Framework	Req/s	Bundle Size
Elysia	25,312	~22kb
Hono	22,124	~14kb
PrinceJS	21,748	4.8kb gzipped
Express	9,325	200kb+

PrinceJS is the smallest Bun framework in this comparison at 4.8kb gzipped. That bundle size is why PrinceJS loads in 97 milliseconds on Slow 3G — a real-world metric that req/s benchmarks don't capture.

For developers building APIs that start up quickly, edge functions, or any backend where cold start time matters — the bundle size difference between PrinceJS and Elysia is meaningful.

What PrinceJS Actually Ships

Despite being 4.8kb gzipped, PrinceJS ships a remarkably complete feature set. This isn't a minimal micro-framework — it's a full-featured framework that's been engineered to stay small.

Feature	Import
Routing	`princejs`
Middleware (CORS, Logger, Rate Limit, Auth, JWT)	`princejs/middleware`
Zod Validation	`princejs/middleware`
Cookies & IP Detection	`princejs`
File Uploads	`princejs/helpers`
WebSockets	`princejs`
Server-Sent Events	`princejs/helpers`
Sessions	`princejs/middleware`
Response Compression	`princejs/middleware`
In-memory Cache	`princejs/helpers`
Cron Scheduler	`princejs/scheduler`
OpenAPI + Scalar Docs	`princejs`
JSX / SSR	`princejs/jsx`
SQLite Database	`princejs/db`
Plugin System	`princejs`
End-to-End Type Safety	`princejs/client`
Deploy Adapters (Vercel, Cloudflare, Deno, Node)	`princejs/vercel` etc.
Lifecycle Hooks	`princejs`

This is the full feature list of a production-ready framework, shipping in 4.8kb gzipped.

Getting Started

bun add princejs
# or
npm install princejs

A complete server with middleware in under 10 lines:

import { prince } from "princejs";
import { cors, logger } from "princejs/middleware";

const app = prince();

app.use(cors());
app.use(logger());

app.get("/", () => ({ message: "Hello PrinceJS!" }));
app.get("/users/:id", (req) => ({ id: req.params.id }));

app.listen(3000);

PrinceJS vs Hono vs Elysia — Which Should You Use?

Use PrinceJS if:

Bundle size and cold start time matter (edge functions, serverless, mobile backends)
You want the most complete feature set in the smallest package
You need deploy adapters for Vercel, Cloudflare Workers, Deno, or Node
You want built-in OpenAPI docs, SQLite, WebSockets, and SSE without adding dependencies

Use Elysia if:

You need the absolute maximum raw req/s
You're heavily TypeScript-first and want Elysia's type system

Use Hono if:

You need Hono's specific middleware ecosystem
You're deploying to Cloudflare Workers natively
You want the second-fastest option with a larger community

The One-Line Summary

PrinceJS is the third fastest Bun framework in the world, 2.3x faster than Express, ships in 4.8kb gzipped with a full production feature set, and was built in three days by a 13-year-old from Abuja, Nigeria.

bun add princejs

Website: princejs.vercel.app
npm: npmjs.com/package/princejs
GitHub: github.com/MatthewTheCoder1218/princejs
X: @Lil_Prince_1218

I Got Bored of Tutorials at 13 and Built a Top-3 Bun Framework Instead

Little Prince — Thu, 19 Mar 2026 18:00:00 +0000

There's a trap that kills most developers before they ever get good.

You finish a tutorial. You understand it. You feel ready. Then you open a blank file and freeze — because the tutorial told you what to type, but it didn't teach you how to think.

So you watch another tutorial. Then another. Then another.

That's tutorial hell. I almost got stuck in it at 13. Instead I built PrinceJS — one of the top three fastest Bun web frameworks in the world.

The Tutorial Hell Trap

I'm from Abuja, Nigeria. I've been coding for a couple of years, mostly through YouTube videos and online courses.

The problem with tutorials is that they're engineered to make you feel productive. You follow along, the code works, and you get the dopamine hit of seeing something run. But when the tutorial ends and you try to build something yourself, you realise you can't.

I watched videos about building to-do apps, weather apps, CRUD apps. People kept saying that building apps like these wouldn't get you anywhere as a developer — that you needed to build something real. I agreed. But I didn't know what "something real" meant. So I watched more tutorials.

Then one day I just got bored.

Not motivated. Not inspired. Just completely bored of watching other people write code. So I closed YouTube and asked myself one question: what do I actually use every day as a developer?

A web framework.

Three Days on a 2015 Windows Laptop

I had no tutorial. No roadmap. Just Bun's source code, some CS reading about trie data structures, and a blank file.

Day one: I built the routing layer. Most frameworks use hash maps for URL routing — O(1) average, but hash collisions degrade performance under heavy concurrent load. I used a compressed trie instead. O(k) where k equals the number of URL path segments. Zero collisions. Fully predictable under any load.

Day two: I had a working server. I ran my first benchmark.

19,036 requests per second on Bun.

I screamed. Genuinely.

Day three: Optimisation. Removed one unnecessary function call from the hot path. Added response header caching. Set a rule I've kept ever since: the bundle stays under 5kb. No runtime dependencies.

Final benchmark: 21,748 requests per second — third fastest Bun framework in the world, benchmarked with oha -c 100 -z 30s on Windows 10.

And because of the 4.8kb gzipped bundle: 97 milliseconds on Slow 3G.

I'm from Nigeria. Slow 3G is real here. I built for it.

What PrinceJS Is Today

Three days turned into a v2 release. PrinceJS now ships a full production feature set — still in 4.8kb gzipped:

import { prince } from "princejs";
import { cors, logger, rateLimit, auth, jwt, session, compress } from "princejs/middleware";
import { cache, upload, sse } from "princejs/helpers";
import { cron } from "princejs/scheduler";
import { db } from "princejs/db";

const app = prince();

app.use(cors());
app.use(logger());
app.use(rateLimit({ max: 100, window: 60 }));
app.use(compress());

// Routes with params
app.get("/users/:id", (req) => ({ id: req.params.id }));

// WebSockets
app.ws("/chat", {
  open: (ws) => ws.send("Connected!"),
  message: (ws, msg) => ws.send(`Echo: ${msg}`),
});

// Server-Sent Events
app.get("/events", sse(), (req) => {
  setInterval(() => req.sseSend({ time: Date.now() }), 1000);
});

// Cached route
app.get("/data", cache(60)(() => ({ time: Date.now() })));

// SQLite
const users = db.sqlite("./db.sqlite", "CREATE TABLE IF NOT EXISTS users (id TEXT)");
app.get("/users", () => users.query("SELECT * FROM users"));

// Cron job
cron("*/1 * * * *", () => console.log("heartbeat"));

app.listen(3000);

Every feature in that example ships inside the 4.8kb bundle. No separate installs. No bloating.

Auto-Generated OpenAPI Docs

One of the features I'm most proud of in v2: define a route once and get runtime validation, type safety, and Scalar UI documentation automatically:

import { prince } from "princejs";
import { z } from "zod";

const app = prince();
const api = app.openapi({ title: "My API", version: "1.0.0" }, "/docs", { theme: "moon" });

api.route("POST", "/users", {
  summary: "Create user",
  tags: ["users"],
  schema: {
    body: z.object({ name: z.string().min(2), email: z.string().email() }),
    response: z.object({ id: z.string(), name: z.string() }),
  },
}, (req) => ({ id: crypto.randomUUID(), ...req.parsedBody }));

app.listen(3000);
// GET /docs → beautiful Scalar UI, auto-updated

End-to-End Type Safety

Define your API contract once, get full TypeScript autocompletion on the client automatically:

type ApiContract = {
  "GET /users/:id": {
    params: { id: string };
    response: { id: string; name: string };
  };
};

import { createClient } from "princejs/client";
const client = createClient<ApiContract>("http://localhost:3000");

const user = await client.get("/users/:id", { params: { id: "42" } });
console.log(user.name); // typed as string ✅

The Real Numbers

Metric	Value
Requests/sec	21,748 (oha -c 100 -z 30s, Windows 10)
Global rank	#3 fastest Bun framework
vs Express	2.3x faster
vs Hono	1.7% slower
Bundle size	4.8kb gzipped
Slow 3G load	97ms
Runtime dependencies	0
npm total downloads	5.2k and growing
Built in	3 days, age 13, Abuja Nigeria

What I Learned

Boredom is a better teacher than motivation. I built PrinceJS because I had nothing to watch — not because I felt inspired. The blank file was the tutorial.

Read source code, not tutorials. In three days of reading Bun's source code and trie papers I learned more than I had in months of following along with videos.

Honesty about tradeoffs builds trust. PrinceJS is 1.7% slower than Hono on req/s. I publish that number openly in the README. Developers respect honesty more than marketing.

Build for the users you know. I'm from Nigeria. I optimised for Slow 3G because I know what it feels like. The 97ms result is a product of building for my reality, not for a benchmark chart.

Try It

bun add princejs

Website: princejs.vercel.app
npm: npmjs.com/package/princejs
GitHub: github.com/MatthewTheCoder1218/princejs
X: @Lil_Prince_1218

If you're stuck in tutorial hell right now — close the video. Open a blank file. Build something you actually use. You don't need permission. You're already ready.

PrinceJS 2.1: The 4.8kB Bun Framework Just Got Even Faster (21.7k req/s) and Fully Loaded

Little Prince — Fri, 13 Mar 2026 01:09:00 +0000

Hey DEV! 👋

A few months ago, I shared that I—a 13-year-old developer from Nigeria—built a Bun framework that outperformed Express. The response was incredible, and the feedback even better.

Today I'm back with PrinceJS v2.1, and I've got some updates to share. The old numbers floating around (19k req/s, 2.4kB gzipped) are outdated. Here's the real story.

⚡ Updated Benchmarks (oha -c 100 -z 30s on Windows 10)

After the community pointed out I should use oha instead of bombardier, I re-ran all tests. The results put PrinceJS firmly in the top three Bun frameworks:

Framework	Req/s	Total Requests (30s)
Elysia	25,312	759k
Hono	22,124	664k
PrinceJS	21,748	653k
Express	9,325	280k

✅ PrinceJS is 2.3× faster than Express.

✅ Still comfortably in the top 3.

📦 True Bundle Size (Not 97kB!)

I also corrected the size reporting. PrinceJS is tree‑shakeable and has zero dependencies. The real numbers:

Minified: 14.7kB
Minified + Gzipped: 4.8kB
Download on Slow 3G: 97ms
Download on Emerging 4G: 6ms

That tiny footprint makes it perfect for edge functions, serverless, and any environment where every kilobyte counts.

✨ What's New in v2.1?

Version 2.1 isn't just a performance fix—it's a massive feature drop. PrinceJS is now a batteries-included super-framework that stays tiny.

📖 OpenAPI + Scalar Docs (Auto‑magical)

const api = app.openapi({ title: "My API", version: "1.0.0" }, "/docs");
api.route("GET", "/users/:id", {
  schema: { response: z.object({ id: z.string() }) },
}, (req) => ({ id: req.params.id }));
// → GET /docs serves a beautiful Scalar UI playground
// → GET /docs.json serves raw OpenAPI spec

🎣 Lifecycle Hooks (Observability built-in)

app.onRequest((req) => { /* ... */ });
app.onBeforeHandle((req, path, method) => { /* ... */ });
app.onAfterHandle((req, res) => { /* ... */ });
app.onError((err, req) => { /* ... */ });

🔌 Plugin System

const myPlugin: PrincePlugin = (app, opts) => { ... };
app.plugin(myPlugin, { prefix: "/api" });

🌍 Deploy Adapters

Deploy anywhere with a single import:

Vercel Edge (princejs/vercel)
Cloudflare Workers (princejs/cloudflare)
Deno Deploy (princejs/deno)
Node.js (native or Express) (princejs/node)

🍪 Cookies & IP Detection

app.get("/profile", (req) => ({
  sessionId: req.cookies?.sessionId,
  clientIp: req.ip,
}));

🧰 Helpers Galore (No Dependencies!)

cron() – schedule jobs natively
cache() – in‑memory TTL cache
upload() – handle file uploads
sse() – server‑sent events
db.sqlite() – SQLite ORM powered by Bun
jwt(), session(), compress() – all in middleware

⚛️ JSX/SSR (Without React)

import { Html, Body, H1, render } from "princejs/jsx";
app.get("/", () => render(Html(Body(H1("Hello PrinceJS!")))));

🔒 End‑to‑End Type Safety

Define a contract once and get full autocomplete on the client:

import { createClient } from "princejs/client";
const client = createClient<ApiContract>("http://localhost:3000");
const user = await client.get("/users/:id", { params: { id: "42" } });
// user.name is typed as string ✅

🚀 Quick Start

bun add princejs

import { prince } from "princejs";
const app = prince();
app.get("/", () => ({ hello: "world" }));
app.listen(3000);

📚 Why PrinceJS?

Most "fast" frameworks are bare‑bones routers. PrinceJS gives you everything you need for production—OpenAPI, cron, SQLite, WebSockets, JSX, adapters—all in 4.8kB gzipped and zero dependencies.

I built this because I wanted a framework that was both tiny and powerful. A framework that a 13‑year‑old in Nigeria could use to build world‑class apps without pulling in hundreds of dependencies.

🔗 Links

GitHub: github.com/MatthewTheCoder1218/princejs
npm: npmjs.com/package/princejs
Website: princejs.vercel.app
Twitter: @princejs_bun

Built with ❤️ in Nigeria.

Try it out and let me know what you build! 🚀

I’m 13 and I built a Bun framework that’s 2x faster than Express 🚀

Little Prince — Sat, 28 Feb 2026 04:05:48 +0000

It’s a 97kB (2.4kB gzipped) Bun-native framework that hits 21,748 req/s.

👑 Why PrinceJS?

Most "fast" frameworks are just bare-bones routers. PrinceJS is a Super-Framework. It’s tiny but has "batteries included":

✅ Built-in SQLite ORM (Powered by Bun.sqlite)
✅ Native Cron Scheduler (No extra npm packages needed)
✅ Functional JSX Rendering (Clean UI without the React bloat)
✅ OpenAPI/Swagger Generation (Auto-sync your docs)
✅ Validation with Zod

⚡ The Benchmarks (oha -c 100 -z 30s)

On an Intel i7-6600U, PrinceJS matches the giants:

Framework	Req/s	Size (Gzipped)
PrinceJS	21,748	2.4 kB
Hono	22,124	7.5 kB
Elysia	25,312	64.8 kB
Express	9,325	~2 MB

🛠️ Minimalist DX


typescript
import { prince } from "princejs";
import { Html, Body, H1, render } from "princejs/jsx";

const app = prince();

app.get("/", () => render(
  Html(Body(H1("Hello from PrinceJS!")))
));

app.listen(3000);

PrinceJS – The Bun Framework Built by a 13-Year-Old Dev. Ranked #3 in Performance.

Little Prince — Thu, 04 Dec 2025 05:53:32 +0000

I’ve been building PrinceJS over the last few months, and today it’s officially among the fastest Bun frameworks available.

Benchmarked with oha -c 100 -z 30s, it hits 21,748 req/s, placing it just behind Elysia (~25k) and Hono (~22k), and well ahead of Express (~9k).

🧰 What’s Inside:

Built-in middleware – CORS, logger, rate limiting, static file serving
Validation – powered by Zod, integrated at the framework level
OpenAPI auto-docs – /docs endpoint out of the box
Helpers – cache(), upload(), email(), cron(), all tree-shakable
JSX support – render HTML directly if needed

Everything is modular, lightweight, and designed for real-world use.

I built this on my school laptop (i7-6600U, 8GB RAM) and optimized it for speed without bloat.

If you're working with Bun and want a clean, fast, full-featured framework — give PrinceJS a try.

🚀 Get Started in Seconds:

bun create princejs my-api
cd my-api
bun dev

📂 GitHub: https://github.com/MatthewTheCoder1218/princejs

⭐ Star it if you’re into fast, clean, open-source tools!

I Built the #1 Fastest Bun Framework At 13 Years Old

Little Prince — Sat, 15 Nov 2025 19:21:58 +0000

PrinceJS just hit 19,200 req/s, beating Hono, Elysia, and
Express.

2.8 kB gzipped\
576k requests in 30s\
21% faster than Elysia\
106% faster than Express

import { prince } from "princejs";
const app = prince();

app.get("/", () => ({ hello: "PrinceJS" }));

app.listen(3000);

Benchmark Results

PrinceJS: 19,200 req/s → 576k\
Hono: 16,212 req/s → 486k\
Elysia: 15,862 req/s → 476k\
Express: 9,325 req/s → 280k

Built in Nigeria. Zero deps. Pure speed.

"I didn't beat them. I destroyed the competition."

🔗 Website: https://princejs.vercel.app\
🔗 GitHub: https://github.com/MatthewTheCoder1218/princejs

I’m 13 and Just Made a Web Framework 3x Faster Than Express

Little Prince — Mon, 10 Nov 2025 06:36:13 +0000

Yesterday I published princejs on npm.

<2 kB
Zero dependencies
Native Bun binary
Built in 3 days on my school laptop
500+ downloads in <24 hours

Same laptop. Same test. Same autocannon command:

Express → 8,000 requests in 10s

princejs → 25,000 requests in 10s

To Start

npm i princejs

or 

pnpm add princejs

Then

import { Prince } from "princejs";
const app = new Prince();

app.get("/", () => app.json({ message: "Wassup" }));
app.listen(3000);

That’s it. No bloat. No legacy. Just speed.

Repo: https://github.com/MatthewTheCoder1218/princejs
npm: https://npmjs.com/package/princejs

Plugged: Instant Backend Integration for Developers

Little Prince — Mon, 22 Sep 2025 05:21:42 +0000

I’m excited to share Plugged — a desktop application that eliminates backend setup friction by automatically connecting your frontend projects to backend services with zero configuration.

Plugged is designed for developers who want to focus on building features, not configuring infrastructure. It handles the repetitive work of setting up backend frameworks, BaaS integrations, and database connections — so you can go from project creation to coding in seconds.

Here’s how it works:

Install the Windows app (MVP)
Select your project folder
Choose your tech stack:
Backend Frameworks: Express, FastAPI, Django
BaaS/Headless: Supabase, Firebase
Databases: PostgreSQL, MongoDB, MySQL, SQLite
Process: Plugged generates the necessary configuration files, sets up secure connections, and integrates services directly into your project
Done: Click “Open Folder” and start developing — no manual setup required

The app uses Tauri for performance and security, with a clean UI that guides you through the process. All operations run locally — no project files are sent anywhere.

Why this matters:

No more copy-pasting boilerplate
No environment variables to manage
No CLI commands to remember
No configuration files to maintain
This is not a code generator that dumps files and leaves you to fix it. It’s a smart integration tool that understands your stack and sets it up correctly.

🔗 GitHub: github.com/MatthewTheCoder1218/plugged
📥 Download: Available via GitHub Releases (Plugged_0.1.0_x64_en-US.msi)

Built for developers who are tired of setup. Feedback and contributions welcome.

— Made with ❤️ by Little Prince
ISC Licensed

BugBlaze: Catch Bugs in JavaScript, Python, and More with One CLI.

Little Prince — Wed, 28 May 2025 00:11:04 +0000

Debugging code is a universal pain, whether it's a JavaScript error, a Python error, or maybe even TypeScript. I built BugBlaze, a CLI tool with 900+ npm downloads last week, to catch errors in multiple languages fast. Here's why I chose to do it and how it has actually saved me.

Why I built it

So one day I hit an error so hard I couldn't fix it. I read articles even used ChatGPT and other AI models. But none of them seemed to be working. And one main thing that I noticed is that they didn't really understand the code. And that's normal because they aren't actually in your codebase. And I don't know if anybody else experiences this, but they were slow (maybe because of my budget laptop 🙂).

So I thought, why don't I build an app or website that integrates that AI into your code? And I know some of you will be thinking, "Why don't you just use GitHub Copilot?". Well, listen to this, I'm.... broke 🙂.

So I went on to build it. And because of my lazy nature, I didn't want to build a website or a desktop app, but I found the idea of a CLI tool nice and easy.

And ta-da, we have BugBlaze 🎉

How to Use BugBlaze In Your Codebase

So let's imagine you have a codebase with a syntax error. You try to fix it (in basic developer knowledge), then you get another error.... ok. So, how do we fix this? With BugBlaze, you have two options:

If you want to fix the error but you don't want to touch the code

bugblaze fun index.js -e

This scans your code, gets the error, and gives it to Groq (who is, by the way, the AI behind the whole CLI and everything), which processes the error and the code file and generates a response on what the issue is and how to fix it.

Or if you have already touched it and it isn't working anymore

bugblaze analyze index.js

This scans the code for logical runtime issues and recommends the best approach on how to make the code work again. So if you don't have any syntax errors, we've got you covered 😉

How it has helped me personally

And now, coming to think of it, I haven't actually used my tool 😁. I mostly just spend so much time building and improving its features (and to make YouTube videos 🙂). But don't worry, I am gonna relax and use it to the full extent 😁.

So why should you use BugBlaze

So personally, I think there are a lot of reasons you should try it out.
It has multiple language support like JavaScript, TypeScript, Python, Java, TSX/JSX (more languages coming soon 😉), it's super fast, it's nice for developers who love the terminal (I mean who doesn't). And you get to put your own API key for privacy, and you can manage what you do with your own API key (definitely not trying to avoid AI request expenses 🙂). But I still think it is actually pretty nice. And also, you get all features for free (for now, though 🙂).

Do you wanna get started 🤩?

I know there are other tools you could use out there instead of mine. I just built this out of pure curiosity and to solve my own needs before I thought to put it out there. But I will be excited and love it if you download it now.

BugBlaze is free (for now, as I said 🙂) and there will be new features coming soon, including premium tier.

You can get started now by running

npm install -g bugblaze

Tell me what you think about this project in the comments, and what I should improve 😁, and kindly give me a star on GitHub if you love this project.

Link to the package: https://www.npmjs.com/package/bugblaze
Docs: https://buglaze.vercel.app
I made it open-source (because I'm nice 🙂): https://github.com/MatthewTheCoder1218/bugblaze