oRPC vs tRPC vs Hono
See how oRPC compares to tRPC and Hono across type safety, OpenAPI support, framework integrations, and runtime performance.
oRPC, tRPC, and Hono all deliver end-to-end typesafe APIs in TypeScript, but they take different approaches. tRPC focuses on RPC for full-stack TypeScript apps, Hono is a general-purpose web framework with an RPC feature, and oRPC combines typesafe RPC with first-class OpenAPI support.
Features
- ✅ First-class, built-in support
- 🟡 Lacks features or requires third-party integrations
- 🛑 Not supported or not documented
Checked against tRPC 11.29 and Hono 4.13 (November 2026).
Type Safety
| Feature | oRPC | tRPC | Hono |
|---|---|---|---|
| End-to-end typesafe input/output | ✅ | ✅ | ✅ |
| End-to-end typesafe errors | ✅ | ✅ | ✅ |
| End-to-end typesafe File/Blob | ✅ | 🟡 | 🟡 |
| End-to-end typesafe Server-Sent Events | ✅ | ✅ | 🛑 |
End-to-end typesafe ReadableStream<Uint8Array> |
✅ | 🛑 | 🛑 |
| Typesafe at scale | ✅ | ✅ | 🛑 |
oRPC types errors per procedure or globally: throw a plain ORPCError, declare errors with a schema for each code’s data on a single procedure or a shared builder, or define them once and reuse them everywhere via an error factory. oRPC is also the only one that types binary data in both directions.
API Design & OpenAPI
| Feature | oRPC | tRPC | Hono |
|---|---|---|---|
| Implementation-first approach | ✅ | ✅ | ✅ |
| Contract-first approach | ✅ | 🛑 | 🟡 |
| OpenAPI spec generation | ✅ | 🟡 | 🟡 |
| Standard Schema (Zod, Valibot, ArkType, …) | ✅ | ✅ | 🟡 |
| Native types (Date, URL, Set, Map, …) | ✅ | 🟡 | 🛑 |
| Custom serializers | ✅ | ✅ | 🛑 |
| Bracket notation | ✅ | 🛑 | 🛑 |
| Lazy router (code splitting, faster cold starts) | ✅ | ✅ | 🛑 |
oRPC serves the same procedures over its RPC protocol and RESTful OpenAPI endpoints, and generates the spec with a first-party package. Native types like Date or Map work out of the box.
Integrations & Ecosystem
Every oRPC integration above is first-party.
Performance
All numbers come from the middleapi/orpc-benchmarks run of November 17, 2026, with oRPC 2.0.0-beta.51, tRPC 11.28.3, and Hono 4.13.19 on Node.js 26.13.1. Each server runs on its own dedicated CPU of a 4-vCPU cloud VM, so the results are single-core throughput. Handlers are no-ops with pass-through validation, so the results measure framework overhead only. Every response carries a Date, so each library’s serializer runs on every request.
Throughput
Median requests per second over 10 rounds, each on a fresh server after a warm-up, with 10 connections that each keep one request in flight:
| Scenario | oRPC | tRPC | Hono |
|---|---|---|---|
| RPC over HTTP (req/s) | 28,118 | 6,976 | n/a |
| RPC over WebSocket (req/s) | 27,448 | 21,095 | n/a |
| OpenAPI (RESTful) over HTTP (req/s) | 28,167 | n/a | 25,410 |
oRPC handles about 4.0x as many requests as tRPC over HTTP and 1.3x over WebSocket. oRPC and Hono are close on RESTful throughput: oRPC is about 11% ahead, which is within the run’s noise. Throughput on a cloud VM drifts over the day: in repeated runs on the same VM type, the RPC-over-HTTP ratio ranged from 3.6x to 4.4x, so only compare numbers from the same run.
Server Cost and Latency
The same rounds also record server CPU time per request, peak memory, and latency:
| Run | CPU / request | Peak RSS | Latency p50 | Latency p99 |
|---|---|---|---|---|
| RPC over HTTP · oRPC | 35.0 µs | 88 MiB | 0.31 ms | 0.86 ms |
| RPC over HTTP · tRPC | 141.3 µs | 318 MiB | 1.11 ms | 5.57 ms |
| RPC over WebSocket · oRPC | 35.4 µs | 115 MiB | 0.31 ms | 1.01 ms |
| RPC over WebSocket · tRPC | 46.7 µs | 84 MiB | 0.40 ms | 1.17 ms |
| OpenAPI over HTTP · oRPC | 34.9 µs | 89 MiB | 0.31 ms | 0.89 ms |
| OpenAPI over HTTP · Hono | 38.4 µs | 94 MiB | 0.34 ms | 0.94 ms |
Over HTTP, oRPC needs about a quarter of tRPC’s CPU time per request. oRPC and Hono are within about 10% of each other on every metric.
Clinic Doctor Profiles
Every server is also profiled with Clinic.js Doctor under the same load. Each profile is a single round, so compare behavior, not throughput:
| Run | CPU (avg) | Memory (RSS) | Event loop delay (avg) | Other detected issues | Full report |
|---|---|---|---|---|---|
| RPC over HTTP · oRPC | 98% | 80-97 MiB | 0.06 ms | none | view |
| RPC over HTTP · tRPC | 99% | 76-249 MiB | 0.86 ms | memory: heapUsed | view |
| RPC over WebSocket · oRPC | 97% | 74-116 MiB | 0.08 ms | cpu: data | view |
| RPC over WebSocket · tRPC | 98% | 75-93 MiB | 0.07 ms | none | view |
| OpenAPI over HTTP · oRPC | 98% | 78-93 MiB | 0.08 ms | none | view |
| OpenAPI over HTTP · Hono | 99% | 73-98 MiB | 0.10 ms | none | view |
Every server is saturated, so Doctor flags event loop utilization on every run. That is expected under this load and left out of the table. The cpu: data flag on oRPC’s WebSocket run means Doctor’s CPU model could not settle on the samples, not a performance issue.
Type-Checking Performance
On a large, fully typed project with 3,000 procedures across 1,501 routers and a typed client call for every procedure, checked with TypeScript 7.0.2 (tsc --singleThreaded), median of 30 rounds:
| Metric | oRPC | tRPC |
|---|---|---|
| Check time | 1.59 s | 1.97 s |
| Total time | 1.81 s | 2.13 s |
| Types | 204,344 | 223,766 |
| Instantiations | 775,928 | 1,043,234 |
| Memory used | 241 MiB | 224 MiB |
oRPC needs about 26% fewer type instantiations and 9% fewer types. Unlike timings, these counts are deterministic and comparable across machines. The check-time gap is within noise.
Hono has no column because its RPC types hit known limits well before this size.
Bundle Size
Bundle sizes for a minimal client and server pair, measured with the same versions. tRPC includes superjson to match oRPC’s built-in native types, and Hono includes @hono/node-server to match the Node.js servers in the other bundles.
| Metric | oRPC | tRPC | Hono |
|---|---|---|---|
| Minified | 49.2 kB | 79.1 kB | 48.1 kB |
| Minified + gzip | 15.9 kB | 25.8 kB | 18.1 kB |