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, Python and Go.

[T]TRY IT FREE [F]FULL COMPARISON

/USED BY LEADING COMPANIES

/AT GLANCE

gRPC 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
Streaming support is limited

Same typed, local-feeling calls - across 14+ runtimes
Expose ordinary classes - no router, no procedures
Install the Graft as a normal npm / NuGet / pip package
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, Python, Go — or Node.

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 monorepo lock-in

tRPC's types only travel inside a monorepo. Graftcode ships a versioned Graft any repo or language installs like a normal package.

[F]FULL COMPARISON

/SHOW, DON'T TELL

Same local feel — now cross-language

The same typed call — getUser(42) — but the caller no longer has to be TypeScript.

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.

/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

Monolith <-> Microservices switch by configuration

[×] NO

Switch remote <-> in-memory with config only

[×] NO

TOPOLOGY & TRANSPORT

Same programming model for queues / event buses

[×] NO

Full streaming

[-] LIMITED

Automatic Native 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
Monolith <-> Microservices switch by configuration	[×] 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	[✓] YES
Automatic Native MCP	[×] NO	[✓] YES

/BY THE NUMBERS

The payoff, in numbers

60%

less code for AI to touch

1/8

of REST/RPC overhead via Hypertube™

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