Build a real modular monolith. Finally.

Graftcode is the first framework that lets you mix languages inside one monolith, then pull any module into its own service — without rewriting a line of business logic.

[T] TRY IT FREE [D] READ THE DOCS

/USED BY LEADING COMPANIES

/THE PROBLEM

Monolith or microservices?

Split too early, you drown.
Too late, you're stuck.

>>> Start with a monolith

and hit a wall the day you actually need to split it.

>>> Start with microservices

and drown in deployment complexity before you've shipped anything.

/THE SOLUTION

Meet Graftcode

The first true polyglot modular monolith

Graftcode connects language runtimes at the native level, not the language level. Mix Python, .NET, Java, and Node.js inside a single process — then pull any module into its own service without touching the code that calls it.

Any language, one process
Run modules written in different languages side by side in the same monolith. No other modular framework allows this — they're all locked to a single stack.
Business logic never touches transport
Call a method the same way whether it executes in memory or over the network. No REST layer to write, no flag to flip in code.
Change the channel without touching code
Direct call today, message queue or load balancer tomorrow — swapped in configuration, not in your application.

/BEFORE & AFTER

Same modules.
Zero rewrites when one goes remote.

Without Graftcode, moving a module out of the monolith means writing a transport layer first. With Graftcode, it's a one-line reference and a config change.

shipping module, called directly

const shipping = new ShippingService();
shipping.schedule(order);const shipping = new ShippingService();
shipping.schedule(order);

A few weeks later - needs to scale

WITHOUT GRAFTCODE

write a REST controller

[HttpPost("schedule")]
public IActionResult Schedule(Order order)
{
    _shippingService.Schedule(order);
    return Ok();
}[HttpPost("schedule")]
public IActionResult Schedule(Order order)
{
    _shippingService.Schedule(order);
    return Ok();
}

write an HTTP client

await _http.PostAsync(
    "http://shipping-svc/schedule",
    JsonContent.Create(order));await _http.PostAsync(
    "http://shipping-svc/schedule",
    JsonContent.Create(order));

wire a flag to toggle local vs remote

if (config.ShippingIsRemote)
{
    await shippingClient.Schedule(order);
}
else
{
    shippingService.Schedule(order);
}if (config.ShippingIsRemote)
{
    await shippingClient.Schedule(order);
}
else
{
    shippingService.Schedule(order);
}

WITH GRAFTCODE

UPDATE GRAFTCODE CONFIG

// graftcode.config
shipping:
transport: network
endpoint: shipping-svc:7420

// application code — unchanged
shipping.schedule(order);// graftcode.config
shipping:
transport: network
endpoint: shipping-svc:7420

// application code — unchanged
shipping.schedule(order);

No transport code in your codebase.
Ever_

No REST controllers or gRPC stubs written just to enable a future split
No feature flags branching between local and remote calls
No rewritten contracts when a module moves to its own process
Same method call, whether the module is next door or on another machine

/WHAT YOU GET

Split now. Or split later.
Either way, it's your call.

Graftcode removes the constraints that force teams to pick an architecture before they understand their own system.

True polyglot modules

Combine Python, .NET, Java, Node.js, and more inside one modular monolith.

No transport lock-in

Choose a channel later — direct calls, queues, or load balancers, swapped through configuration.

One calling convention

The same method call syntax whether a module is in-process or across the network.

Zero conditional code

No "if remote" branches, no local-vs-remote toggles cluttering the logic you actually maintain.

Split without rewrites

Extract any module into its own service without touching the code that calls it.

Scale only what needs it

Add instances, queues, or load balancers to a single module exactly when it earns them.

[G]GET STARTED

/FAQS

Before you ask

Yes. Modules written in different languages run side by side in the same process and call each other as methods. There is no HTTP hop while they stay in-memory, and no other modular framework lets you mix stacks this way.