Compare
tRPC vs. Graftcode

Same local feel. Any language.

tRPC's typed calls stop at the TypeScript border. Graftcode gives you the same feel across .NET, Java/Kotlin, Python, JavaScript/TypeScript, Ruby and PHP

[T]TRY IT FREE [F]FULL COMPARISON

/USED BY LEADING COMPANIES

/AT GLANCE

tRPC vs Graftcode

Both give you great typed DX. The difference shows the moment you leave TypeScript.

Great typed DX - but only if the whole stack is TypeScript
Needs a router + procedures - the router is your contract
No in-process ↔ remote switch by configuration
No native MCP / AI-agent exposure

Strongly typed, remote calls - across 143 technology pairs
Expose pure classes and public methods
Install always up to date - strongly typed client (Graft) as a normal npm / NuGet / pip / packagist / rubygems dependencies
In-process ↔ remote is a config switch, not a rewrite
Public methods become MCP tools automatically

/WHY SWITCH

Three reasons teams move from tRPC

tRPC gave TypeScript a great typed RPC. The limits show the moment you leave the monorepo, add a second language, or bring in an AI agent.

Typed call reaching Graftcode from outside a TypeScript-only stack

One feel, every language

tRPC's type safety stops at the TypeScript border. Graftcode gives you the same local-call feel whether the other side is .NET, Java/Kotlin, Python, JavaScript/TypeScript, Ruby and PHP.

A public method exposed without a tRPC router

No router, just methods

tRPC needs a router and procedures that become your contract. Graftcode reads your plain public methods — nothing to define, distribute, or keep in sync.

A Graft package installed outside a single monorepo

No need to share source files

tRPC requires either a monorepo or explicit sharing of router types with the frontend. Graftcode, on the other hand, turns any public API into installable packages that you can manage and update just like any other dependency in your project even when consuming third-party APIs.

[F]FULL COMPARISON

/SHOW, DON'T TELL

Same local feel — now cross-language

The same typed call - getUser(42) - but the project no longer has to be purely in TypeScript or share any source files between client and server.

TRPC

define a router

export const appRouter = router({
  getUser: publicProcedure
    .input(z.object({ id: z.number() }))
    .query(({ input }) => db.find(input.id)),
});
export type AppRouter = typeof appRouter;

infer client types

const trpc = createTRPCClient<AppRouter>({ links });
const user = await trpc.getUser.query({ id: 42 });

GRAFTCODE

expose a class

public class UserService {
  public User GetUser(int id) => _db.Find(id);
}

call from any language

from acme_user_service import UserService

user = UserService.get_user(42)

Same typed, local-feeling call.tRPC keeps it inside TypeScript - Graftcode takes it across every runtimes and use cases.

/FEATURE MATRIX

The honest, line-by-line comparison

CapabilityTRPC

PROGRAMMING MODEL

Call with Strongly Typed Methods

[✓] YES

Regular Exception support

[-] PARTIAL

Complex DTOs & arrays passed by value in one call

[✓] YES

PROGRAMMING DEPENDENCIES & CONTRACTS

No additional SDK

[×] NO

No contract files

[×] NO

Use remote modules as dependencies

[-] PARTIAL

TOPOLOGY & TRANSPORT

Switch between WebSocket, HTTP/2, TCP, queues, events, or PaaS channels with a single env var.

[×] NO

Switch remote <-> in-memory with config only

[×] NO

TOPOLOGY & TRANSPORT

Same programming model for queues / event buses

[×] NO

Full streaming

[-] LIMITED

Expose methods are immediately callable via MCP

[×] NO

TRPC compared with Graftcode
Capability	TRPC	Graftcode
PROGRAMMING MODEL
Call with Strongly Typed Methods	[✓] YES	[✓] YES
Regular Exception support	[-] PARTIAL	[✓] YES
Complex DTOs & arrays passed by value in one call	[✓] YES	[✓] YES
PROGRAMMING DEPENDENCIES & CONTRACTS
No additional SDK	[×] NO	[✓] YES
No contract files	[×] NO	[✓] YES
Use remote modules as dependencies	[-] PARTIAL	[✓] YES
TOPOLOGY & TRANSPORT
Switch between WebSocket, HTTP/2, TCP, queues, events, or PaaS channels with a single env var.	[×] NO	[✓] YES
Switch remote <-> in-memory with config only	[×] NO	[✓] YES
TOPOLOGY & TRANSPORT
Same programming model for queues / event buses	[×] NO	[✓] Via plugins
Full streaming	[-] LIMITED	[-] PARTIAL
Expose methods are immediately callable via MCP	[×] NO	[✓] YES

/BY THE NUMBERS

The payoff, in numbers

60%

less code for AI to touch

1/8

of CPU usage comparing to REST or gRPC

coding languages supported

package managers supported

/FAQS

Before you ask

Inside TypeScript, tRPC is genuinely low-ceremony — that's its strength. But it still needs a router that acts as your contract, it's confined to the TypeScript/JavaScript ecosystem, and it has no config-driven topology or MCP path. Graftcode keeps the low ceremony and removes those limits.

/COMMUNITY

Join grafters community

Many developers are loving Graftcode and what it brings to them.

“Graftcode appears to be an exceptionally useful platform. Its key value proposition is allowing developers to concentrate on core business requirements instead of tedious service integration tasks. I believe the concept of beginning with a monolithic structure and then having the option to dynamically transition to a microservice architecture will prove to be extremely valuable.”