A distributed workflow engine and state machine library for Go that implements aspect-oriented programming and the actor model.
asyncmachine-go is a Go library that provides a distributed workflow engine and state machine implementation. It manages the execution of code handlers based on active states, enabling complex concurrency patterns, fault tolerance, and transparent remote procedure calls. It solves the problem of orchestrating asynchronous operations in a structured, debuggable manner.
Go developers building distributed systems, workflow engines, stateful applications, or real-time systems requiring fine-grained concurrency control and observability.
Developers choose asyncmachine-go for its unique combination of aspect-oriented programming, actor model principles, and clock-based state management, which minimizes handler code while maximizing scenario coverage. Its built-in tooling for debugging, telemetry, and visualization reduces operational complexity.
state machine which runs code
Open-Awesome is built by the community, for the community. Submit a project, suggest an awesome list, or help improve the catalog on GitHub.
Includes a TUI debugger (am-dbg) and integrated telemetry for observability, with screenshots showing OpenTelemetry traces and interactive inspection, making distributed workflows traceable.
Offers transparent RPC and selective distribution, allowing remote state machines to use the same API as local ones, facilitating scalable distributed systems without code changes.
Uses aspect-oriented programming and actor models to manage graph-structured concurrency with goroutine cancelation, minimizing handler code while covering complex scenarios, as shown in the samples.
Provides REPL, CLI tools, and diagram generators (am-vis) for development and visualization, enhancing productivity and understanding of state transitions.
The README states that some packages are 'alpha or testing,' leading to potential instability and breaking changes in higher-level features like node and pubsub.
Requires understanding novel concepts like clock-based state machines and aspect-oriented handlers, which can be challenging for developers unfamiliar with stateful systems.
Described as having 'acceptable performance,' it may not be optimal for high-throughput scenarios where raw speed is critical, due to the overhead of state management and telemetry.
Defining state schemas and relations can be complex and verbose, as seen in the sample schemas with extensive relational definitions, increasing initial setup time.