Official BLOGE Website

Orchestrate Enterprise Business Logic with Precision

BLOGE keeps orchestration inside a zero-dependency Java core, schedules each operator on virtual threads, and lets teams move between a fluent API and a declarative DSL without changing the runtime.

Zero dependencies on the core runtime
Virtual-thread concurrency for every operator
Declarative graphs that stay readable and reviewable

Read the Docs View on GitHub

Java 25+Virtual threads, ScopedValue context propagation, and low-friction concurrency.

Dual authoringUse GraphBuilder in code or ship standalone .bloge assets.

Production readySpring Boot, durability, observability, linting, and visual tooling included.

Trace a business graph from parallel fetches to an approval branch without changing authoring style or runtime behavior.

fetchUsertimeout 3s

fetchProductsparallel source

calcPricefan-in aggregation

checkCreditbranch decision

createOrderapproved path

rejectOrderotherwise path

BLOGE DSL

graph orderProcess {
  node fetchUser : FetchUserOperator { timeout = 3s }
  node fetchProducts : FetchProductsOperator { timeout = 5s }
  node calcPrice : CalcPriceOperator {
    depends_on = [fetchUser, fetchProducts]
  }
  branch on checkCredit.output.approved {
    true -> createOrder
    otherwise -> rejectOrder
  }
}

Platform highlights

The orchestration stack your teams can actually ship.

BLOGE focuses on the real problems behind enterprise orchestration: concurrency, resilience, traceability, and tooling that does not force a platform rewrite.

Zero Dependencies

Run the core orchestration engine on java.base alone and embed it into existing services without dragging a runtime platform behind it.

Virtual Thread Concurrency

Every operator can execute on its own virtual thread, so parallel fan-out remains simple and blocking I/O stays cheap.

Built-in Resilience

Configure retry, timeout, and fallback policies per operator to keep failure handling visible in the graph definition.

DSL

Declarative DSL

Use HCL-style .bloge files when the workflow should be reviewed, linted, and evolved independently from Java source code.

Spring Boot Ready

Auto-discover operators, load DSL graphs from the classpath, and expose actuator endpoints for runtime introspection.

Saga & Compensation

Attach compensate operators and a graph-level saga block to unwind committed work with configurable ordering, failure policy, and retry budget.

Durable Recovery

Lease renewal, checkpoint resume, and sequential foreach recovery let crashed executions resume from the first missing item with no schema migration.

Agent Loop & LLM SPI

A first-class agent DSL with tool bindings and memory strategies, plus tool calling and structured output through the extended LlmProvider SPI.

Remote Workers

Mark any node execution_mode = remote to delegate it to an external worker via durable, topic-sharded work items with heartbeat and dead-letter flows.

Visual Studio IDE

Bloge Studio brings Sugiyama layout, schema-aware editing, and exportable graph assets to teams who prefer a visual authoring loop.

What shipped recently

Production capabilities, explorable in one place.

BLOGE has grown well beyond plain DAGs. Step through the newest building blocks — saga compensation, durable recovery, AI agents, remote workers, and a live ops console — and watch each flow animate.

Declarative compensation that unwinds on failure

Attach a compensate operator to any node and let a graph-level saga block decide ordering, failure policy, and retry budget when something downstream blows up.

Backward, forward, or custom compensation ordering
compensate / skip / fail_fast failure policies
Per-node outcomes via GraphResult.compensationResults()

reserveStockcommitted

chargeCardcommitted

createShipmentfailed

refundCardcompensating

releaseStockcompensating

Read the Saga & Compensation guide →

Saga DSL

graph checkout {
  saga {
    order = backward
    on_failure = compensate
    max_compensation_retries = 2
  }

  node reserveStock : ReserveStockOperator {
    compensate releaseStock : ReleaseStockOperator
  }
  node chargeCard : ChargeCardOperator {
    compensate refundCard : RefundCardOperator {
      retry = { attempts: 3, backoff: 200ms }
    }
  }
  node createShipment : CreateShipmentOperator {
    depends_on = [reserveStock, chargeCard]
  }
}

Built for enterprise-grade workflows

From service orchestration to human-in-the-loop flows.

The examples in the BLOGE repository are not toy graphs. They demonstrate the kinds of bounded, high-value workflows that teams actually need to version, observe, and maintain.

Loan Approval Workflow

Parallel credit, fraud, income, and blacklist checks converge into an auditable decision graph for approval, rejection, or manual review.

Based on the finance/LoanApproval examples and their four-way risk fan-out.

Order Processing

User lookup, product fetch, price calculation, credit checks, and conditional order creation stay visible as one coherent fulfillment flow.

Mirrors the orderProcess examples in both Java API and .bloge form.

BFF

BFF Data Aggregation

Fan out to multiple downstream services, attach different fallback policies per branch, and reassemble a single backend-for-frontend payload.

Modeled after the BffAggregation example with five-way parallelism.

AI Voice Agent

Session, phase, and round primitives support multi-turn, long-running conversational orchestration with handoff and wrap-up phases.

Backed by the customer-service session DSL and voice-oriented example graphs.

From definition to execution in three steps

Model once, then keep the same runtime path everywhere.

The BLOGE toolchain keeps authoring, execution, and observability aligned, so you do not have to maintain separate models for developers, operators, and platform teams.

Define

Describe the graph in a plain-text .bloge file so operators, dependencies, and resilience stay explicit and reviewable.

BLOGE DSL

graph orderProcess {
  node fetchUser : FetchUserOperator {
    input { userId = ctx.userId }
    timeout = 3s
  }

  node calcPrice : CalcPriceOperator {
    depends_on = [fetchUser, fetchProducts]
    input {
      user     = fetchUser.output
      products = fetchProducts.output
    }
  }
}

Execute

Run the same graph with the Java engine. BLOGE schedules ready nodes on virtual threads and keeps the orchestration contract stable.

Java runtime

Graph graph = loader.load("classpath:bloge/order-process.bloge");
GraphEngine engine = GraphEngine.builder()
    .registry(registry)
    .build();

GraphResult result = engine.execute(
    graph,
    new GraphContext(Map.of("userId", userId, "productIds", productIds))
);

Observe

Attach metrics, tracing, and structured logs so retries, timeouts, fallback paths, and execution latency surface in production dashboards.

Observability

GraphEngine.builder()
    .registry(registry)
    .listeners(List.of(new MetricsExecutionListener(meterRegistry, "bloge")))
    .interceptors(List.of(new TracingOperatorInterceptor(tracer)))
    .build();

# Grafana panels
bloge.graph.duration
bloge.node.retries
bloge.node.fallbacks

Start in minutes

Choose the authoring style that fits your team.

BLOGE keeps Java API and DSL authoring aligned, so you can prototype in text, move stable logic into code, or keep the graph external for platform and ops workflows.

Maven dependency

pom.xml

<dependency>
  <groupId>com.leanowtech.bloge</groupId>
  <artifactId>bloge-core</artifactId>
  <version>\${bloge.version}</version>
</dependency>

Minimal graph

Java API

Graph graph = Graph.builder("helloBloge")
    .node("echo", echoOperator)
        .input((results, ctx) -> Map.of("message", ctx.get("message", String.class)))
    .build();

GraphResult result = GraphEngine.builder().build()
    .execute(graph, new GraphContext(Map.of("message", "hello")));

→ Read the full Getting Started guide

A complete ecosystem

Tooling that keeps DSL, Java, and docs in sync.

VSVS Code ExtensionSyntax highlighting, diagnostics, completion, hover, and formatting for .bloge files.STBloge StudioA browser-based DAG editor with layout, schema awareness, and .bloge export.LSPLSP ServerShared language intelligence for editors, automation, and static analysis.MVNMaven PluginExport operator metadata and run lint checks during your build pipeline.BPMNBPMN TransformerTranslate BPMN models into BLOGE DSL or executable graphs with diagnostics.AGTAgent Extensionagent { tool ... } DSL with memory strategies and the extended LlmProvider SPI.RWRemote WorkersDelegate nodes to external worker processes over durable, topic-sharded work items.OPSOps ConsoleEmbedded /bloge-console SPA with timelines, topology, task claim, and dead-letter replay.