ing-bank/baker

Baker is an open-source library for orchestrating microservice processes using recipes defined in Java, Kotlin, or Scala. It provides a runtime that manages process instances, events, and interactions, supporting both local execution and distributed clustering via Akka. The system includes HTTP interfaces for remote interaction, a web dashboard for monitoring, and comprehensive testing utilities to verify recipe behavior.

12 changes.

This period established the Baker project's open-source foundation, including comprehensive documentation, CI infrastructure, and a suite of runnable examples in Java and Scala. The core runtime underwent significant architectural changes, introducing a composable event API, configurable type conversion modules, and standardized interfaces across DSLs. Extensive test coverage and observability tooling were integrated to support the new API and validate the microservice orchestration capabilities.

10 changes.

This period focused on establishing external interaction capabilities by introducing the HTTP server and a web-based dashboard for managing recipes and instances. Concurrently, the project expanded its testing ecosystem with a dedicated baker-test module for validating recipe executions and enhanced the HTTP client with robust failover and TLS support.

12 changes.

This period focused on migrating core components from Scala to Kotlin, including the recipe compiler, DSL interfaces, and in-memory runtime, while introducing a new Akka-based actor runtime for scalable execution. It also established a standalone HTTP service for remote interaction execution and restructured the state management module to support clustering and persistence via Akka Cluster and Cassandra.

The \http\ directory now includes the \baker-http-dashboard\, an Angular-based web interface that allows users to view added recipes, inspect and execute interactions manually, and monitor the status of process instances. This dashboard consumes endpoints exposed by the \baker-http-server\ library and is configured via \reference.conf\ to be enabled by default under the \baker.dashboard\ section. The implementation includes Scala backend components for serving static assets securely and handling configuration, alongside a full Angular frontend setup with TypeScript, ESLint, and Protractor for end-to-end testing.

http · high confidence

The Java baker example now includes a complete webshop workflow implementation in the \webshop.simple\ package. This adds a \JWebshopRecipe\ defining the process flow (Order Placed → Payment → Reserve Items → Ship Items) along with the corresponding interaction interfaces (\MakePayment\, \ReserveItems\, \ShipItems\) and their concrete instances. It also introduces the necessary data models (ingredients) such as \Item\, \PaymentInformation\, \ReservedItems\, and \ShippingAddress\ to support the example's state management.

examples/baker-example/src/main/java · high confidence

The \examples/baker-example/src/main/scala/webshop/simple\ directory now contains a complete Scala-based webshop example, including \SimpleWebshopRecipe\ and \SimpleWebshopRecipeReflection\ which define the workflow (events like OrderPlaced, PaymentMade, and interactions like ReserveItems), as well as \SimpleWebshopInstances\ and \SimpleWebshopInstancesReflection\ which provide the concrete logic for handling interactions such as reserving items.

examples/baker-example/src/main/scala/webshop/simple · high confidence

The Baker example now ships with a complete local environment for running, monitoring, and testing the service. It includes a Docker Compose setup to launch a three-node cluster alongside Prometheus, Grafana, and HAProxy. Grafana is pre-configured with an Akka metrics dashboard to visualize actor activity and JVM memory, while Prometheus is set up to scrape metrics from the cluster nodes. Additionally, a Gatling simulation is provided to load-test the checkout flow against the example service.

examples/baker-example/src/main/resources · high confidence

The bakery-state module has been restructured to provide a new Akka-based runtime implementation. This includes new configuration files (reference.conf, application.conf) defining Akka Cluster settings, sharding, and persistence plugins (Cassandra/In-memory). The code introduces a new AkkaBakery component that wires up subcomponents (interaction registry, event sink, watcher) using Cats Effect Resources for lifecycle management. It also adds a ClosableBakery wrapper for easier integration and a Main entry point that starts the HTTP server and recipe polling. Test resources have been added to support these changes, including embedded Cassandra configuration and Kubernetes API mocks.

bakery/bakery-state, core/baker-intermediate-language · high confidence

This change introduces the HTTP server component for the Baker runtime, providing a new entry point to interact with recipes via HTTP. It includes a default configuration (reference.conf) for the API host, port, URL prefix, and logging, which is loaded via the new Http4sBakerServerConfiguration. The server exposes standard Baker operations (adding recipes, baking, managing instances) through both Scala and Java DSLs, including support for metadata on bakes and event instance handling. Additionally, it integrates a developer dashboard that can be enabled or disabled via configuration, serving static assets and configuration endpoints.

http/baker-http-server · high confidence

This change introduces the initial open-source release of the Baker project, establishing the foundational repository structure. It adds a comprehensive README.md detailing the library's purpose (microservice process orchestration via Java, Kotlin, or Scala DSLs), usage examples, and Maven/Gradle/Scala SBT integration instructions. The release also includes a new MkDocs-based documentation site configuration (mkdocs.yml) with navigation for concepts, tutorials, and cookbooks, alongside developer documentation (docs.md) explaining the automated CI and release workflows. Additionally, it sets up essential project infrastructure files such as .gitignore, .codecov.yml for coverage thresholds, .scala-steward.conf for dependency management, and the MIT LICENSE.

(repo-wide) · high confidence

Users can now run Baker recipes using an Akka actor system, which provides local or cluster-sharded execution modes. This runtime introduces a new configuration structure (baker.conf and reference.conf) allowing control over actor timeouts, snapshot intervals, ingredient filtering, and encryption. It also enforces secure defaults by disabling Java serialization and binding Baker-specific types to a protobuf serializer, while providing Java DSL entry points (AkkaBaker.java) for integration.

core/baker-akka-runtime · high confidence

The Baker HTTP Dashboard is now available, providing a web-based interface to manage and interact with Baker recipes and instances. Users can view cluster information, browse available recipes, and inspect running instances, including their events and ingredients. The dashboard supports executing interactions manually by providing input ingredients, firing sensory events, and visualizing recipe graphs. It also allows users to delete instances and deactivate recipes, with a responsive layout that adapts to mobile and desktop views.

http/baker-http-dashboard · high confidence

Baker now provides a new Kotlin implementation for compiling recipes into Petri nets, located in the \core/baker-compiler-kotlin\ module. This change introduces a new set of runtime data classes (such as \Recipe\, \Interaction\, \Event\, and \Ingredient\) and compiler utilities like \RecipeCompilerKotlin\ and \PreCompileValidations\ to handle the compilation logic. To support this, the \core/baker-annotations\ module now includes new qualifier annotations like \@AsyncInteraction\, \@FiresEvent\, and \@RequiresIngredient\ that allow developers to define interaction behaviors and dependencies directly in Kotlin code. The compiler bridges existing Scala recipe definitions to this new Kotlin model, enabling users to compile recipes using Kotlin DSLs or annotations while maintaining compatibility with the underlying Scala infrastructure.

core/baker-annotations, core/baker-compiler-kotlin, core/baker-recipe-manager · high confidence

A new \bakery-interaction\ module has been added to provide a standalone HTTP server for executing Baker interactions remotely. This service exposes an API (defaulting to port 8081) that accepts interaction requests via POST and returns execution results, while also listing available interaction definitions via GET. The implementation supports mutual TLS authentication using configurable JKS keystores, includes a separate health check endpoint (port 9999), and optionally exposes Prometheus metrics on a dedicated port (default 9096) for monitoring interaction success and failure rates.

bakery/bakery-interaction · high confidence

The \core/baker-types\ module now provides a pluggable system for converting between internal Baker values and Java/Scala types. This change adds a \reference.conf\ configuration file that maps Java and Scala classes (such as \java.util.List\, \scala.Option\, \java.time.LocalDate\, and Joda Time types) to specific \TypeModule\ implementations. Corresponding Scala source files (\Converters.scala\, \TypeAdapter.scala\, \TypeModule.scala\, and various modules in the \modules\ package) implement the logic to read these configurations, instantiate the appropriate converters, and handle serialization/deserialization for primitives, collections, enums, records, POJOs, and time types.

core/baker-types · high confidence

Added comprehensive Java and Kotlin code snippets in the examples/docs-code-snippets directory to demonstrate the Baker runtime API. The Java examples cover recipe definition (including sub-recipes, failure strategies, and event transformations), interaction handling, and event firing/awaiting patterns. The Kotlin examples provide equivalent demonstrations using Kotlin DSL features, including coroutine-based asynchronous operations and the InMemoryBaker for local testing.

examples/docs-code-snippets · high confidence

The Kotlin DSL runtime interface is now implemented in Kotlin, providing a \Baker\ class that wraps the existing Java DSL to expose a coroutine-based API (suspend functions) for managing recipe instances, firing events, and querying state. This location also introduces the in-memory baker implementation in Kotlin, allowing users to create an in-memory runtime via \InMemoryBaker.kotlin()\, and adds support for defining interactions using Kotlin functions and classes through \FunctionInteractionInstance\ and \ClassInteractionInstance\.

core/baker-interface-kotlin/src/main · high confidence

This change introduces the \baker-test\ module, providing a testing library with concise assertion tools for Java and Scala users to verify recipe execution, event flows, and ingredient states. It also adds a README for the core directory to document the available recipe DSLs and runtime implementations, alongside a new worksheet script for build maintenance tasks.

core · high confidence

The webshop example now exposes an HTTP service built with http4s and cats-effect, allowing users to interact with the Baker runtime via REST endpoints. Users can place orders, add shipping and payment details, and poll order status through the /api route, while the /admin route provides a shutdown hook and a heap memory dump endpoint. This replaces the previous interaction model with a standard JSON API for the checkout flow.

examples/baker-example/src/main/scala/webshop/webservice · high confidence

The bakery-kafka-listener-example now includes a complete Scala-based application that listens to a Kafka topic for Baker events. It features a configurable consumer (using fs2-kafka) that deserializes incoming JSON messages into BakerEvent or EventInstance objects and delegates processing to a user-defined EventProcessor implementation. The example also provides a Java reference implementation of the EventProcessor trait and standard configuration/logging resources to demonstrate how to integrate external Kafka consumers with the Baker runtime.

examples/bakery-kafka-listener-example · high confidence

The examples/bakery-client-example directory now contains a complete, runnable Scala application that demonstrates a webshop checkout flow using the Baker runtime. This example includes a recipe definition (CheckoutFlowRecipe) modeling order placement, item reservation, payment, and shipping interactions, along with a web service layer (WebShopService) exposing HTTP endpoints for creating orders, updating address and payment information, and polling order status. It also features a management client (StateNodeManagementClient) for querying recipe and instance state, and is configured via application.conf and logback.xml.

examples/bakery-client-example · high confidence

The \baker-compiler-scala\ module has been extracted into its own Maven module, containing the Scala implementation of the recipe compiler (\RecipeCompilerScala\) and its associated assertions and utilities. A new Kotlin implementation (\RecipeCompiler\) has been added to the \core/baker-compiler\ module, which now acts as a facade that compiles recipes using both the Scala and Kotlin compilers, compares their outputs for equivalence, and returns the Scala result if they match or adds validation errors if they differ. This change supports the migration from the Scala compiler to a Kotlin implementation while ensuring behavioral consistency.

core/baker-compiler, core/baker-compiler-scala · high confidence

The Akka actor runtime has been significantly restructured to support improved persistence, clustering, and delayed transitions. New protobuf schemas define the internal state for process instances, process indices, recipe management, and delayed transitions, including the persistence of correlation IDs in transition events. The runtime now introduces a pluggable cleanup abstraction with specific implementations for Cassandra and generic actor-based stores. Clustering capabilities are enhanced via a new ClusterBakerActorProvider that leverages Akka Cluster Sharding and Cluster Bootstrap, alongside dedicated GracefulShutdown logic to handle shard handover and cluster leave procedures. A new DelayedTransitionActor manages timed interactions with snapshotting, while utility classes for timeouts, logging with MDC, and persistence initialization support the new architecture.

core/baker-akka-actors · high confidence

The core Baker interface has been refactored to replace the legacy callback-style event handling (fireEvent, fireEventAndResolveWhenReceived, etc.) with a new composable API (fireSensoryEventAndAwaitReceived, awaitEvent, awaitCompleted), with the old methods marked for removal in December 2026. The interface now supports attaching metadata at process creation via the bake method, allows deleting recipe instances, and exposes a new executeSingleInteraction method for running interactions outside of a process context. Additionally, a default TimerInteraction is now provided in the runtime, configurable via the baker.default-interactions.timer.skip setting, and the entire interface is standardized across Scala and Java DSLs using a LanguageApi abstraction.

core/baker-interface/src/main · high confidence

The Baker HTTP client has been updated to handle connection failures more robustly by introducing automatic failover logic. If a request to the primary Baker host fails, the client will automatically retry on alternative hosts or a configured fallback endpoint, using an exponential backoff strategy defined in the new \baker.client.failover\ configuration section (initial delay and retry count). Additionally, the client now supports TLS connections via \TLSConfig\ and \KeystoreConfig\, allowing users to secure communications with custom keystores and trust managers.

http/baker-http-client/src/main · high confidence

The in-memory implementation of the Baker runtime interface has been rewritten from Scala to Kotlin. This change introduces new Kotlin source files for the core in-memory components (InMemoryBaker, InMemoryRecipeInstanceManager, InMemoryEventStream, InMemoryInteractionManager, and InMemoryRecipeManager) while retaining Scala-based test suites to verify the behavior. For users, this represents a language-level refactor of the in-memory runtime module, maintaining the existing API surface (including Java DSL compatibility) but shifting the internal implementation language.

core/baker-interface-in-memory · high confidence

The Java and Kotlin recipe DSLs now allow interactions to specify their name via a dedicated \name\ field, which is used during interaction execution. This change aligns the DSL definition with the existing support for the name field at the execution level, ensuring consistency in how interactions are identified and referenced within recipes.

core/baker-recipe-dsl · medium confidence

The Kotlin DSL for recipe definitions now allows users to specify a custom name for interactions via the \name\ property in the interaction builder. Previously, interactions were identified by their class name; this change enables explicit naming, which is consistent with the interaction execution level. This is demonstrated in the test suite where interactions like \MakePayment\ and \ReserveItems\ are assigned custom names such as \MakePayment2\ and \ReserveItems2\.

core/baker-recipe-dsl-kotlin · high confidence

Added Baker test module with assertion utilities; Added Java DSL interaction test fixtures and comprehensive Baker model test suite; Added integration and unit tests for the Baker HTTP client; Added test suite and configuration for the Baker example application; Added tests for Kotlin DSL interface parity and function interactions; Added tests for the Java webshop recipe example; Added tests for the baker-test module; Added unit tests for Java DSL test utilities.

This release adds a Kotlin compiler and runtime alongside the existing Scala implementation, enabling users to define recipes in Kotlin. The project has been restructured into new modules including \bakery-interaction-protocol\, \bakery-interaction\, \bakery-state\, \baker-akka-actors\, \baker-akka-runtime\, \baker-annotations\, \baker-compiler-kotlin\, \baker-compiler-scala\, \baker-compiler\, \baker-interface-in-memory\, \baker-interface-kotlin\, and \baker-interface\. The build system now integrates the Kotlin Maven plugin and dependencies such as \kotlin-stdlib\, \kotlinx-coroutines-core\, and \kotlin-test-junit\ to support the new language capabilities.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 51.

• Code Health 90
• Architecture 82
• Maturity 62
• Readiness 36
• Security 68
• Accessibility 58

• 300 commits — 254 feature/other, 46 fixes

• project/Dependencies.scala — 70 commits
• core/akka-runtime — 44 commits
• (root) — 39 commits
• core/baker-interface — 26 commits
• .github/workflows — 16 commits
• project/plugins.sbt — 14 commits
• bakery/state — 11 commits
• bakery/dashboard — 8 commits
• core/recipe-dsl — 8 commits
• bakery/interaction — 7 commits
• docs/sections — 5 commits
• http/baker-http-dashboard — 5 commits
• bakery-integration-tests/src — 4 commits
• bakery/baker-unified — 3 commits
• core/baker-akka-actors — 3 commits
• core/baker-interface-kotlin — 3 commits
• core/baker-test — 3 commits
• core/recipe-dsl-kotlin — 3 commits
• examples/docs-code-snippets — 3 commits
• bakery/baker-client — 2 commits

• fix: 1488 transform event fix (#1490)
• fix: Bugfix for the in-memory baker stop execution. It sometimes stopped mid execution. (#1804)
• fix: Bugfix: add metadata together with process initilization (#1818)
• fix: Correctly add the baker-test module to the baker build and fixed the test.
• fix: Feature/fix and improve test coverage (#1314)
• fix: Fix build (#928)
• fix: Fix build status and maven central badges (#1437)
• fix: Fix classpath issues of bakery-state (#1184)
• fix: Fix eventmoment times & removed the S and E generics (#1900)
• fix: Fix for init failure recovery (only applies when baking the failed instance again). (#1929)
• fix: Fix initialize cmd persist failure (#1453)
• fix: Fix issue when interactions.class = "" (#1086)
• fix: Fix publish release (#1305)
• fix: Fix release pipeline by adding quotes to the sbt release command (#1757)
• fix: Fix the bug that the ProcessInstance would passivate on retry interaction if that interaction took too long. (#1936)
• fix: Fix the internal index to correctly tag processes as active. (#1888)
• fix: Fix to make a local startup of the unified Baker possible useful for local testing. (#816)
• fix: Fix/await completed race condition async (#1944)
• fix: Fix/execute single interaction response (#1282)
• fix: Fix/expired certificates (#1281)
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

ing-bank/baker was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.