0.9.8-RC1Latest release · Verify Preview

Make business logic executable.

Describe a graph in Java or BLOGE DSL, run it on one engine, then add resilience, durability, agents, observability, and verification as the workflow grows.

Read the Docs View on GitHub

Zero-dependency Java core virtual-thread scheduling one Graph model

One graph · five capability views

LIVE EXECUTION · APPROVED PATHIndependent reads run together, then the graph joins their outputs.

Watch the payload move left to right: two ready nodes run in parallel before pricing and credit approval.

Graph input: customerId=C-104 · productIds=[P-7,P-9]
Graph result: orderId=O-2048

RUNNINGLoad customercustomerId → customer

RUNNINGLoad inventoryproductIds → stock

WAITINGCalculate pricecustomer + stock → total

WAITINGCheck creditcustomer + total → approved

WAITINGCreate orderapproved order → orderId

NOT TAKENManual reviewfallback case → reviewId

approved = true otherwise

Loading interactive Graph…

Now running: Load customer + Load inventoryapproved = true

Why BLOGE

One model, from first node to production operation.

Zero-dependency core

Embed the engine

Keep orchestration inside the Java service that owns the business logic instead of adopting a second runtime platform.

Java + BLOGE DSL

Model the graph once

Java and BLOGE DSL converge on the same Graph and the same virtual-thread execution semantics.

Capabilities stay modular

Grow without changing models

Add resilience, durability, agents, remote workers, observability, and verification around the graph as requirements grow.

BLOGE 0.9.8-RC1

One Graph model. Add capabilities as the workflow grows.

Start with explicit execution, then step through resilience, durable recovery, AI agents, remote workers, observability, and the latest verification capability.

Make dependencies, concurrency, and decisions explicit

Java builders and standalone .bloge assets converge on one Graph model. GraphEngine schedules ready nodes on virtual threads and keeps every branch visible.

Zero-dependency core runtime on java.base
One execution model for Java and BLOGE DSL
Explicit dependency, branch, loop, and result semantics

Java / DSLdefine once

Graphone model

ready nodesvirtual threads

branchexplicit path

GraphResulttyped output

Read the Core Graph & DSL guide →

BLOGE DSL

graph orderProcess {
  node loadCustomer : CustomerOperator
  node loadInventory : InventoryOperator
  node calculatePrice : PriceOperator {
    depends_on = [loadCustomer, loadInventory]
  }
  branch on checkCredit.output.approved {
    true -> createOrder
    otherwise -> manualReview
  }
}

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.

The maintained starter adds two BLOGE Verify Suites and seven business Cases.

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.LSPLSP ServerShared language intelligence for editors, automation, and static analysis.MVNMaven PluginExport operator metadata and run lint checks during your build pipeline.VERIFYBLOGE VerifyPreview business-contract execution, evidence, and decision-gate assessment.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.