Compare
REST vs. Graftcode

No controllers. No DTOs. Just methods.

REST works everywhere — but you hand-write controllers, DTOs and serialization for every endpoint. Graftcode turns your methods into a typed client.

[T]TRY IT FREE [F]FULL COMPARISON

/USED BY LEADING COMPANIES

/AT GLANCE

REST vs Graftcode

REST is the universal HTTP contract. As a way to call your own services, it's a lot of hand-written plumbing.

Universal — every language and tool speaks HTTP
...but you write controllers, routes and DTOs
Real end-to-end types need OpenAPI + codegen
Errors map to HTTP status codes on both sides
No config-driven remote switch; no native MCP

Same typed, local-feeling calls — across 14+ runtimes
Expose ordinary classes — no controllers, no DTOs
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 REST

REST is the universal edge contract. For internal service and app calls, its plumbing is pure overhead.

A method call replacing a REST controller and DTO

No controllers, no DTOs

REST makes you hand-write controllers, routes, DTOs and JSON serialization for every endpoint. Graftcode exposes your public methods directly.

A typed Graft that refreshes without an OpenAPI codegen step

Types without codegen drift

REST is strongly-typed over the wire; real types mean an OpenAPI spec and a codegen step that drifts. Graftcode ships a typed Graft that auto-refreshes.

Caller packages updating when a method signature changes

No versioning treadmill

Change a REST response and you version endpoints and chase every client. Graftcode updates each caller's typed Graft when the signature changes.

[F]FULL COMPARISON

/SHOW, DON'T TELL

Same call. Controller + client vs a method

Fetching one user — the REST plumbing vs a direct typed call.

REST

controller + route + DTO

[ApiController]
public class UsersController : ControllerBase {
  [HttpGet("/users/{id}")]
  public ActionResult<UserDto> Get(int id) =>
    _db.Find(id).ToDto();
}

client: fetch + parse, no real types

const res = await fetch(`/users/42`);
const user = await res.json(); // any

GRAFTCODE

expose a class

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

Install the Graft & call

from acme_user_service import UserService

user = UserService.get_user(42)

Same call, fully typed.REST needs a controller, a DTO and a client - Graftcode needs a method.

/FEATURE MATRIX

The honest, line-by-line comparison

CapabilityREST

PROGRAMMING MODEL

Call with Strongly Typed Methods

[×] NO

Regular Exception support

[×] NO

Complex DTOs & arrays passed by value in one call

[✓] YES

PROGRAMMING DEPENDENCIES & CONTRACTS

No additional SDK

[-] PARTIAL

No contract files

[×] NO

Use remote modules as dependencies

[×] NO

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

[-] PARTIAL

Automatic Native MCP

[×] NO

REST compared with Graftcode
Capability	REST	Graftcode
PROGRAMMING MODEL
Call with Strongly Typed Methods	[×] NO	[✓] YES
Regular Exception support	[×] NO	[✓] YES
Complex DTOs & arrays passed by value in one call	[✓] YES	[✓] YES
PROGRAMMING DEPENDENCIES & CONTRACTS
No additional SDK	[-] PARTIAL	[✓] YES
No contract files	[×] NO	[✓] YES
Use remote modules as dependencies	[×] NO	[✓] 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	[-] PARTIAL	[✓] 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

At the edge, yes - keep REST for public and partner APIs. Internally, hand-writing controllers, DTOs and clients for every service call is overhead REST doesn't remove. Graftcode gives typed calls between your own services; REST stays at the boundary.

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