vs. every major framework

One framework. Twenty categories.
Zero dependencies.

HBForge ships 76 modules covering everything a modern application needs — HTTP server, UI runtime, ORM, validation, animation, charts, 3D, auth, mail, PDF, tests, search, i18n, AI, GraphQL, WebSockets, queues, cron, OpenAPI. Every one of them replaces a popular package — or several. Here's the head-to-head.

76modules

100+packages replaced

1npm dependency

0transitive deps

Typical modern stack

15+ packages · 1,200+ transitive deps

react react-dom react-router express fastify hono prisma drizzle zod framer-motion chart.js three passport auth.js lucia nodemailer pdfkit jest commander i18next react-hot-toast flexsearch apollo-server ws bullmq node-cron workbox openai langchain

~480 KB bundle weeks to audit

HBForge

1 package · 0 transitive deps

@hyperbridge/forge

Everything above — server, UI, ORM, validation, animation, charts, 3D, auth, mail, PDF, tests, CLI, i18n, search, toasts, GraphQL, WebSockets, queues, cron, PWA, AI — in one tree-shakeable, audit-able, zero-dependency package.

~438 KB bundle 1 codebase to audit

The matrix

Every category, every alternative.

20 categories where the modern JavaScript ecosystem has 3–5 popular options. HBForge collapses each into one module.

Three stacks, before & after.

Common production stacks rewritten as one HBForge import. Same behaviour, dramatically fewer moving parts.

REST API: Express + Zod + Prisma + Auth + Mail

Classic Node.js REST stack — five popular libraries plus their transitive trees.

−5 deps

~180 transitive

Before5 packages

import express from 'express';
import { z } from 'zod';
import { PrismaClient } from '@prisma/client';
import bcrypt from 'bcrypt';
import jwt from 'jsonwebtoken';
import nodemailer from 'nodemailer';

const app    = express();
const db     = new PrismaClient();
const mail   = nodemailer.createTransport({ /* ... */ });
const schema = z.object({ email: z.string().email(), pw: z.string().min(8) });

app.use(express.json());

app.post('/signup', async (req, res) => {
  const p = schema.safeParse(req.body);
  if (!p.success) return res.status(400).json(p.error);
  const hash = await bcrypt.hash(p.data.pw, 12);
  const user = await db.user.create({ data: { email: p.data.email, hash } });
  await mail.sendMail({ to: user.email, subject: 'welcome', text: 'hi' });
  res.json({ token: jwt.sign({ uid: user.id }, process.env.SECRET) });
});

app.listen(3000);

After1 package

const { WebApp, ObjectSchema, StringSchema } = require('@hyperbridge/forge/server');
const { Pool, Model }                       = require('@hyperbridge/forge/data');
const { Password, JWT }                     = require('@hyperbridge/forge/auth');
const { Mailer }                            = require('@hyperbridge/forge/mail');

const app    = new WebApp();
const db     = new Pool({ url: process.env.DATABASE_URL });
const User   = new Model('users', { id: 'serial', email: 'text', hash: 'text' });
const mail   = new Mailer({ /* SMTP */ });
const schema = new ObjectSchema({ email: new StringSchema().email(), pw: new StringSchema().min(8) });

app.post('/signup', async (c) => {
  const r = schema.validate(await c.req.json());
  if (!r.valid) return c.json(r.errors, 400);
  const hash = await Password.hash(r.value.pw);
  const user = await User.create(db, { email: r.value.email, hash });
  await mail.send({ to: user.email, subject: 'welcome', text: 'hi' });
  return c.json({ token: JWT.sign({ uid: user.id }, process.env.SECRET) });
});

app.listen(3000);

Web app: React + Framer Motion + Chart.js + react-hot-toast

SPA with animations, data viz, and notifications — four packages plus React's tree.

−4 deps

~340 transitive

Before4 packages

import { useState }              from 'react';
import { motion }                from 'framer-motion';
import { Line }                  from 'react-chartjs-2';
import { Chart, registerables } from 'chart.js';
import { toast, Toaster }        from 'react-hot-toast';

Chart.register(...registerables);

export default function App() {
  const [count, setCount] = useState(0);
  return (
    <div>
      <Toaster />
      <motion.button
        animate={{ scale: 1 + count * 0.05 }}
        onClick={() => { setCount(count + 1); toast.success('clicked'); }}>
        Clicked {count}
      </motion.button>
      <Line data={{ /* ... */ }} />
    </div>
  );
}

After1 package

const { useState, h }            = require('@hyperbridge/forge/client');
const { Animated, Spring }       = require('@hyperbridge/forge/animate');
const { LineChart }              = require('@hyperbridge/forge/chart');
const { toast, Toaster }         = require('@hyperbridge/forge/notify');

function App() {
  const [count, setCount] = useState(0);
  return h('div', null,
    h(Toaster),
    h(Animated.button, {
      animate: { scale: 1 + count * 0.05 },
      onClick: () => { setCount(count + 1); toast.success('clicked'); },
    }, `Clicked ${count}`),
    h(LineChart, { data: /* ... */ }),
  );
}

Edge stack: Hono + Drizzle + Better Auth + Resend

Modern Cloudflare Workers stack — four Fetch-API-compatible packages.

−4 deps

~90 transitive

Before4 packages

import { Hono }                   from 'hono';
import { drizzle }                from 'drizzle-orm/d1';
import { users }                  from './schema';
import { betterAuth }             from 'better-auth';
import { Resend }                 from 'resend';

const app = new Hono();
const auth = betterAuth({ /* config */ });

app.all('/api/auth/*', (c) => auth.handler(c.req.raw));

app.get('/users', async (c) => {
  const db = drizzle(c.env.DB);
  return c.json(await db.select().from(users));
});

app.post('/notify', async (c) => {
  const { to } = await c.req.json();
  const resend = new Resend(c.env.RESEND_KEY);
  await resend.emails.send({ to, from: 'me@x', subject: 'hi', html: '<p>hi</p>' });
  return c.json({ ok: true });
});

export default app;

After1 package

import { WebApp }            from '@hyperbridge/forge/server';
import { Pool, Model }       from '@hyperbridge/forge/data';
import { Password, JWT }     from '@hyperbridge/forge/auth';
import { Mailer }            from '@hyperbridge/forge/mail';

const app  = new WebApp();
const User = new Model('users', { id: 'serial', email: 'text' });

app.post('/api/auth/login', async (c) => {
  const { email, pw } = await c.req.json();
  /* verify hash, return JWT */
  return c.json({ token: JWT.sign({ email }, c.env.SECRET) });
});

app.get('/users', async (c) => {
  const pool = new Pool({ url: c.env.DATABASE_URL });
  return c.json(await User.findAll(pool));
});

app.post('/notify', async (c) => {
  const { to } = await c.req.json();
  await new Mailer({ apiKey: c.env.MAIL_KEY })
    .send({ to, from: 'me@x', subject: 'hi', html: '<p>hi</p>' });
  return c.json({ ok: true });
});

export default app;

Bundle size

Same features, smaller ship.

Total bundle size for an equivalent full-featured app, gzipped.

Next.js + Prisma + Zod + NextAuth + TailwindReact full-stack

~620 KB

Express + Prisma + Zod + Passport + NodemailerClassic REST API

~480 KB

Hono + Drizzle + Better Auth + ResendModern edge stack

~295 KB

Fastify + TypeORM + Yup + Auth.jsEnterprise REST API

~510 KB

@hyperbridge/forgeAll features above — zero deps

438 KB

Measured: full module set, esbuild-bundled, gzipped. Per-module imports are ~5–40 KB each — tree-shake what you don't need.

Beyond parity

What every other framework leaves out.

Categories that don't exist in React, Express, Hono, Next.js, or any combination of npm packages.

🛡️Web7-L6 AAA conformance

30/30 spec tests passing across identity, AMP, AIG, governance, observability, content provenance, ZK-ML oracle. Built-in. require('@hyperbridge/forge/conformance').runConformance().

📜Built-in governance layer

Charter, risk-tier, jurisdiction, drift detection, circuit-breaker, chaos drills, mediation, bounty, succession, assembly. RFC-0007 through RFC-0017, 11 modules.

📡Observability stack

Policy enforcement, distributed tracing, request replay, scenario simulator. Production telemetry without sending data to a third party.

🧬Barnes-Hut physics engine

True O(n log n) N-body simulator with SoA layout, XPBD constraints, SPH fluids, inline Web Worker — for force graphs, particle systems, real-time viz. forge/physics.

🔐Single audit surface

One codebase, one CHANGELOG, one CVE history. Compare to Next.js + Prisma + NextAuth + Tailwind: 4 vendors, 4 release cadences, 1200+ transitive packages to monitor.

🚀Same code, every runtime

The new WebApp runs identically on Node, Bun, Deno, Cloudflare Workers, Vercel Edge. No adapter packages, no rewriting, no per-runtime branches.

Twenty categories. One install.

Stop assembling a stack. Start shipping. npm i @hyperbridge/forge gives you everything above with zero transitive dependencies and one codebase to audit.

npm i @hyperbridge/forge 25 examples vs. Hono in detail Read the docs

One framework. Twenty categories.Zero dependencies.

Typical modern stack

HBForge

Every category, every alternative.

Three stacks, before & after.

REST API: Express + Zod + Prisma + Auth + Mail

Web app: React + Framer Motion + Chart.js + react-hot-toast

Edge stack: Hono + Drizzle + Better Auth + Resend

Same features, smaller ship.

What every other framework leaves out.

🛡️Web7-L6 AAA conformance

📜Built-in governance layer

📡Observability stack

🧬Barnes-Hut physics engine

🔐Single audit surface

🚀Same code, every runtime

Twenty categories. One install.

One framework. Twenty categories.
Zero dependencies.