Comparison

Feature matrix

Architecture differences

Single package vs 35 packages

Katman ships everything as one npm install katman with subpath imports:

import { katman } from "katman"
import { createClient } from "katman/client"
import { katmanHono } from "katman/hono"
import { otelWrap } from "katman/otel"

oRPC requires separate installs: @orpc/server, @orpc/client, @orpc/react-query, @orpc/openapi, @orpc/zod, etc. Both approaches work — single package is simpler to manage, monorepo packages allow finer dependency control.

Guard / Wrap vs middleware chain

Most RPC libraries have one middleware type. Katman has two:

• Guard — runs before, enriches context. No next(). Sync fast-path.
• Wrap — runs before AND after (onion). Has next(). For timing, caching, error capture.

oRPC:    middleware → middleware → middleware → handler
Katman:  guard → guard → guard → [wrap → [wrap → handler]]

Guards are semantically clearer and faster (no async overhead when sync). oRPC's single middleware is more flexible.

Compiled pipeline vs runtime dispatch

Katman compiles the middleware chain once at startup:

• Guards are unrolled (0-4 specialization, no loop)
• Context pool eliminates per-request allocation
• Handler analysis skips unused features

oRPC evaluates the chain at runtime per request. More flexible for dynamic middleware, but Katman is faster for static pipelines.

Content negotiation vs RPC protocol

Katman inspects Accept header and responds in the matching format (JSON, MessagePack, or devalue). Standard HTTP, works with any client.

oRPC uses its own RPC protocol that natively handles Date, File, Blob, BigInt without negotiation. Simpler for oRPC-to-oRPC, less interoperable with non-oRPC consumers.

tRPC uses JSON by default, SuperJSON via transformer for rich types.

Benchmarks

All benchmarks run on the same machine (Apple M3 Max, Node v24.11.0). Sequential requests to isolate per-request latency.

Pipeline performance (no HTTP, pure execution)

Measures raw middleware pipeline overhead — how fast the framework processes a call after TCP/HTTP is stripped away.

Katman's compiled pipeline (unrolled guards, context pool) is 3-6x faster than oRPC and 9-18x faster than H3 at the pipeline level.

HTTP performance (Katman vs oRPC vs H3 vs Hono)

Real HTTP servers, real TCP connections, 3000 sequential requests per scenario.

For simple routes, all four are within 10% — TCP overhead dominates. As middleware complexity grows, Katman's compiled pipeline pulls ahead: 1.5x faster than oRPC and 1.2-1.3x faster than H3/Hono with guards + validation.

Katman serve() vs Nitro v3 (real server)

Real Nitro dev server process vs Katman serve(), 2000 requests.

Nitro adds srvx abstraction, H3 middleware chain, and Node→Fetch conversion per request. Production builds would be faster, but the H3/srvx layer remains.

Tail latency (p99)

Katman's p99 is 34% lower than oRPC and 37% lower than H3 — compiled pipelines keep tail latency predictable.

Memory usage

50K calls, 3 guards + Zod validation, measured with --expose-gc

WebSocket performance

2000 sequential messages over persistent connection

WebSocket eliminates TCP handshake overhead. All three are close — H3 is slightly faster here.

What the benchmarks don't show

• Real-world APIs spend 95%+ of time in DB queries and business logic. Pipeline overhead matters most for high-throughput, low-latency services.
• Nitro production would be faster than dev mode (watcher/HMR overhead removed).
• All benchmarks are sequential (1 connection). Concurrent load may show different characteristics.

node --experimental-strip-types bench/vs-all.ts     # Katman vs oRPC vs H3 vs Hono
node --experimental-strip-types bench/vs-nitro.ts   # vs real Nitro server
node --experimental-strip-types bench/pipeline.ts   # pipeline only (no HTTP)

Where oRPC is ahead

Being honest about oRPC's strengths:

• Ecosystem breadth — 35 packages with more niche integrations (React SWR, Vue Pinia Colada, Hey API, Sentry)
• Cloudflare Durable Objects — Hibernation + Durable Iterator support
• RPC protocol — Native type serialization without header negotiation
• Community size — Larger user base means more battle-tested edge cases
• Angular support — TanStack Query for Angular

Where Katman is ahead

• Single package — one install, no version coordination
• Compiled pipeline — measurably faster, lower p99 latency
• Guard / Wrap model — clearer separation of concerns
• Content negotiation — standard HTTP, interoperable with any client
• Built-in Scalar — scalar: true in serve() for API docs
• HTTP/2 support — one-flag TLS setup
• Auto port selection — no EADDRINUSE handling needed

When to choose what

What's next?

• Getting Started — build your first Katman API
• Examples — download and run in one command
• Migrating from tRPC — step-by-step guide