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
.bloge assets.Trace a business graph from parallel fetches to an approval branch without changing authoring style or runtime behavior.
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.
ZD
Zero Dependencies
Run the core orchestration engine on java.base alone and embed it into existing services without dragging a runtime platform behind it.
VT
Virtual Thread Concurrency
Every operator can execute on its own virtual thread, so parallel fan-out remains simple and blocking I/O stays cheap.
RS
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.
SB
Spring Boot Ready
Auto-discover operators, load DSL graphs from the classpath, and expose actuator endpoints for runtime introspection.
ST
Visual Studio IDE
Bloge Studio brings Sugiyama layout, schema-aware editing, and exportable graph assets to teams who prefer a visual authoring loop.
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.
LA
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.OP
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
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.
01
Define
Describe the graph in a plain-text .bloge file so operators, dependencies, and resilience stay explicit and reviewable.
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
}
}
}02
Execute
Run the same graph with the Java engine. BLOGE schedules ready nodes on virtual threads and keeps the orchestration contract stable.
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))
);03
Observe
Attach metrics, tracing, and structured logs so retries, timeouts, fallback paths, and execution latency surface in production dashboards.
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.fallbacksStart 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
<dependency>
<groupId>com.leanowtech.bloge</groupId>
<artifactId>bloge-core</artifactId>
<version>\${bloge.version}</version>
</dependency>Minimal graph
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")));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.