Topology is a compile flag.

Name: Prism
Author: Wolfigs

Develop one modular monorepo against distributed semantics. Verify its boundaries on every commit. Compile it, deterministically, to a monolith or to microservices. Same code, same tests, both shapes.

Get started on GitHub Developer Guide

$ mvn prism:compile -Dprism.topology=services

The problem

“We'll split it later” is a promise five years of coupling always breaks.

Teams correctly start with a monolith and plan to extract services when scale demands it. Then the coupling accumulates, and “later” arrives as a two-year rewrite. The monolith-vs-microservices decision gets made years before the information needed to make it exists, and unmaking it costs enormously.

Prism makes the promise enforceable. Boundaries are declared, not inferred, and a verifier guarantees in CI that they hold. Deployment topology becomes a reversible, per-environment compile flag instead of a bet placed on day one.

How it works

Distributed semantics from day one. Running as a monolith is free.

Declare modules and contracts

A module is a package. A contract is its only public surface, and it must admit failure by type. The verifier rejects anything else.

PaymentContract.java

@Contract
public interface PaymentContract {

    @Deadline(millis = 2000)
    Result<Receipt> charge(ChargeRequest request);
}

Call it like plain Java

Inject the interface. The Result type forces you to handle failure, which is exactly what makes the same code correct over a network.

OrderService.java

return payment
    .charge(new ChargeRequest(customerId, amount))
    .map(receipt -> placeOrder(receipt))
    .fold(
        order -> accepted(order),
        failure -> switch (failure.kind()) {
            case TIMEOUT, UNAVAILABLE -> retryLater();
            case REJECTED -> tellUser();
            // ...
        });

Verify on every commit

Six deterministic rules fail the build on boundary violations, including transactions that span modules. Rejected, not “handled”.

mvn prism:verify

ERROR [transaction-containment] OrderService.java:42
Transactional method OrderService.place calls contract
PaymentContract of module 'payment', transactions
must not span module boundaries

Compile to either topology

One deployable for dev and small scale. N services, with generated HTTP bindings, Dockerfiles, and compose, when a module needs its own life. Byte-identical on every run.

prism.yml

modules:
  order: { port: 8081 }
  payment: { port: 8082, deadline-ms: 2000 }
packs:
  -  builtin:gateway
  - builtin:observability

What you get

A compiler, a verifier, and an honest set of escape hatches

Declared boundaries

Modules are packages you declare, not guesses a tool makes. Verification is decidable; inference never was.

Fallible by type

Cross-module calls return Result<T> in both topologies. In monolith mode the failure branches simply never fire.

Six verification rules

Boundary integrity, contract fallibility, transaction containment, data ownership, event honesty, declaration sanity, in CI, deterministic.

Deterministic compiler

Same monorepo, byte-identical output, enforced by compile-twice-compare-bytes tests in Prism's own suite.

Template packs

Gateway, observability, Kafka, expressed in a structural template language anyone can extend. The built-ins contain zero Java.

The customization ladder

Annotations → overlays → runtime bindings → ejection. Every escape hatch lives in the monorepo; generated output is never hand-edited.

The guarantee

You were writing distributed-safe code all along.

The classic monolith-to-microservices failure is that the semantics change under the code: in-process calls can't time out, can't partially fail, and are transactional for free. Prism flips the abstraction, you always code against distributed semantics, and the in-process binding is just an execution optimization that happens to never fail.

Kill a service's dependency and it stays up, returning the failure your code already handles, because the type system made you handle it on day one.

the same code, both topologies

// monolith:  local dispatch, never fails
// services:  HTTP + deadline, can fail
Result<Receipt> result = payment.charge(request);

// either way, you wrote the failure path:
result.fold(ok -> ship(), failure -> degrade());

Develop like a monolith.Deploy like microservices.

Open source, Apache-2.0. Java 21+. The verifier alone is worth the install, adopt it without ever compiling.

wolfigs/prism on GitHub About Wolfigs