One artifact spans the whole lifecycle. You build the graph with execution inference and a full DSL, ship it as plain Java, a native image, or WebAssembly, and prove it with deterministic replay and audit baked into the engine.
Run it in the browser — Fluxtion in WebAssembly In development
From intent to a wired graph — you write nodes, the compiler wires them.
Pass constructor references and Fluxtion topo-sorts the graph and generates the dispatch order. No manual wiring, no runtime routing.
When several trigger paths converge on the same node, the compiler emits one guarded call — the shared node is visited once per event, not once per path. Convergent (diamond) graphs that make reactive libraries re-propagate exponentially stay linear.
Imperative nodes (@OnEventHandler / @OnTrigger), a functional DSL (map / filter / groupBy / window / aggregate / join), and Spring-XML declarative modules — mix freely; all converge on the same generated processor.
Any Java method is an operator via method references. Business logic stays vanilla Java — testable outside the flow, with no framework imports in your domain code.
@ServiceRegistered injects host services into nodes; @ExportService exposes a node as a typed command surface the host calls like any Java reference.
@Initialise / @Start / @Stop let nodes manage their own resources and external connections within the deterministic lifecycle.
Dirty filtering — @OnTrigger(dirty) branches — so a node only fires its dependents when its relevant state actually changed.
One graph, many homes — the same dispatcher, compiled for where it runs.
In-process compile, interpreted, AOT (build-time), or compileDispatcher live-binding. Pick the shape by what your code does after compile — fixed binary or a graph you regenerate at runtime.
The dispatcher is emitted as a readable .java file during the build. Your only runtime dependency is fluxtion-runtime — no compiler at startup, no reflection on the hot path.
The Maven plugin emits GraalVM reachability metadata and ships reflect-config, so the plain-Java dispatcher compiles to a native binary — one that starts like any native executable: milliseconds, no JVM to warm up (the AOT example launches and processes events in ~16 ms). Serverless- and edge-friendly.
On the roadmap: compile the dispatcher to a portable WebAssembly module so the deterministic core embeds in non-JVM stacks — Python agent frameworks especially. Not shipped yet.
The generated dispatcher is plain Java source — your IDE navigates it, your VCS diffs it, your auditor reads it. No bytecode manipulation, no framework dark matter.
Deploy the dispatcher into the Mongoose server for agent-threading, ready-made connectors (Kafka, Aeron, Chronicle, JDBC, WebSocket), and a web admin console.
Reproduce, don’t just observe — transparency that survives a regulator.
Structured, low-allocation event logging is built into the engine — every node activation and decision can be recorded on the hot path, not bolted on afterwards.
GraphML node id == generated Java variable == audit-log identity. One name across the diagram, the code, and the trail — debugging and visualisation are unambiguous.
Scrub any captured event, watch the graph light the path the dispatcher took, read each node’s state, and jump to the source line — in the playground and the Mongoose console.
Same input + same graph = the same decision path, reproducibly from the same inputs. You don’t trust the record — you re-run it and get the same answer. The property regulated decisioning is built on.
Set standard breakpoints in the flat generated class and step the entire event-propagation path — no framework internals to get lost in.