Comparison

Feature matrix

Architecture differences

Single package vs 35 packages

Silgi ships everything as one npm install silgi with subpath imports:

import { silgi } from 'silgi'
import { createClient } from 'silgi/client'
import { silgiHono } from 'silgi/hono'
import { otelWrap } from 'silgi/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. Silgi 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
Silgi:  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

Silgi 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 Silgi is faster for static pipelines.

Content negotiation vs RPC protocol

Silgi 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.

Silgi'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 (Silgi 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, Silgi's compiled pipeline pulls ahead: 1.5x faster than oRPC and 1.2-1.3x faster than H3/Hono with guards + validation.

Router performance (Silgi compiled vs rou3)

JIT-compiled radix tree router vs rou3's compiled router.

Silgi's router uses indexOf fast path for simple branches (avoids split()), switch-based charCodeAt dispatch, and compile-time substring() for wildcards.

Tail latency (p99)

Silgi'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.
• All benchmarks are sequential (1 connection). Concurrent load may show different characteristics.

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 Silgi is ahead

• Single package — one install, no version coordination, no transitive dependency issues
• Compiled pipeline — measurably faster, lower p99 latency
• Guard / Wrap model — clearer separation of concerns
• Typed guard errors — guards declare errors that auto-merge into procedures and OpenAPI spec
• Response caching — cacheQuery() with TTL, SWR, dedup, pluggable backends via unstorage
• Rich type serialization — Set, Map, Date via devalue codec without extra plugins
• Content negotiation — standard HTTP, interoperable with any client
• Built-in Scalar — scalar: true in serve() for API docs, with offline mode (cdn: 'local')
• HTTP Cache-Control — route: { cache: 60 } for CDN/browser caching
• HTTP/2 support — one-flag TLS setup
• Auto port selection — no EADDRINUSE handling needed

What's next?

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