Ever stared at a screen at 2 AM, tracing why your OAuth callback lacks that crucial authorization code?
That’s gone now. Tramli—a new open-source state machine—hands developers bulletproof flows where invalid transitions flat-out won’t compile. Real people win: coders reclaim sleep, teams ship faster, users dodge outages.
Boom.
And here’s the thrill: this isn’t just another library. It’s a verification engine, treating state bugs like type errors. You declare states, transitions, what data each step needs and spits out. Build it? Eight checks fire. Miss a dependency? Startup crashes—before production eats your lunch.
Look, we’ve chased ghosts in finite state machines forever. OAuth flows. Order processing. User auth. Ten states, endless callbacks, token refreshes ambushing like thieves. Three hours debugging, null checks everywhere, then—bam—another edge case two weeks later.
Tramli says no.
What Makes Tramli Tick?
You define enums for states, mark what’s available initially, chain transitions with processors that require and produce types. Then .build(). Magic.
Take orders:
var flow = Tramli.define(“order”, OrderState.class) .initiallyAvailable(OrderRequest.class) .from(CREATED).auto(PAYMENT_PENDING, new StartPayment()) .from(PAYMENT_PENDING).external(CONFIRMED, new PaymentGuard()) .from(CONFIRMED).auto(SHIPPED, new ShipOrder()) .build();
If ShipOrder needs PaymentResult but no upstream processor makes it—build() explodes. At startup. Not in the wild.
It verifies reachability, no orphans, full paths covered. Every non-terminal has an out, terminals reachable. No duplicates. Data chains satisfied everywhere.
This. Changes. Everything.
But wait—XState? Solid, 29K stars, hierarchies, parallels. Love it.
Yet it skips requires/produces. Context floats free; types hint but can’t prove “this field’s here on every path.” Exponential paths kill verification.
Tramli flips it: flat enums only. Paths enumerable. Full proof. Trade expressiveness for guarantees. Need Harel charts? Hierarchy plugin compiles to flat—verification intact.
Genius.
Why Does Tramli Crush OAuth Nightmares?
That flow that birthed this: 9 states, OIDC auth. Procedural? 1,800 lines, token bugs galore. Tramli? 50 lines, zero state issues. Structurally impossible.
from(CALLBACK_RECEIVED).auto(EXCHANGING, new ExchangeCode()) from(EXCHANGING).auto(VALIDATING, new ValidateTokens())
ExchangeCode always gets authorizationCode from CallbackGuard. Proved.
And data flow? .dataFlowGraph().toMermaid() spits diagrams. Self-documenting flows. No drift.
graph LR StartPayment –>|produces PaymentIntent| PaymentGuard PaymentGuard –>|produces PaymentResult| ShipOrder
Visual bliss.
Three langs—Java ref (3K lines), TS, Rust (2.2K each). Shared YAML tests. Identical behavior. Core frozen: verification kernel. Plugins for eventstore, audit, lint, observability, idempotency. Future-proof.
My hot take? This echoes Tony Hoare’s null regret—billion-dollar mistake. Type systems slayed nulls. Tramli slays state holes. Next era: software that compiles correct flows. Bold? Yes. Coming? Absolutely.
Imagine CI/CD where flows self-prove. No more “works on my machine” states. Teams scale without tribal knowledge.
But is it hype?
Nah. Creator tired of bugs, built it. Open source. Multi-lang parity screams serious.
Is Tramli Better Than XState for Critical Flows?
XState: rich, visual. Tramli: lean, provable.
Pick by need. Parallels? XState. Data guarantees? Tramli. Plugins bridge gaps.
Here’s the wonder: state machines underpin everything—servers, UIs, protocols. Tramli makes them trustworthy as math.
Developers, you’re pioneers. This shifts platforms like containers did orchestration. Flows become commodities—reliable, swappable.
Energy surges thinking of it.
Rust impl? Same API, zero-cost abstractions verifying paths. TS? TypeScript’s inferring chains. Java? Battle-tested.
Plugins? Audit diffs data per transition. Eventstore replays, compensates. Observability sinks metrics. Lint enforces policies.
Hierarchy plugin—author fancy, compile flat. Best worlds.
Not for modals (too simple). For meaty flows: payments, auth, workflows.
Scale? Shared tests prove cross-lang fidelity. Frozen core scales forever.
Prediction: 2025, tramli in Kubernetes operators, serverless sagas. Bugs? Relic.
Thrilling.
And the Mermaid? Bundled diagrams for docs. Markdown catalogs too.
Flows as code—living docs.
How Will Tramli Reshape Your Dev Workflow?
Grab it. Define enum. Chain. Build. Deploy fearless.
Bugs shift to logic, not structure. Velocity up.
Unique edge: multi-lang lifts monoliths to polyglots smoothly. Microservices with shared flow logic? Yes.
Worlds collide—in good ways.
Skeptics: “Too rigid.” Counter: rigidity early beats chaos late.
Embrace.
🧬 Related Insights
- Read more: LangsCompare.site: Benchmarking Languages Beyond the Popularity Contest
- Read more: Claude Cracks Open Liftoff’s API with mitmproxy—And Builds the Escape Hatch
Frequently Asked Questions
What is tramli state machine?
Tramli is a constrained flow engine for Java, TypeScript, and Rust that verifies state transitions and data flows at build time, preventing invalid states from ever compiling.
How does tramli prevent OAuth bugs?
By requiring processors to declare input/output types, tramli checks every path ensures data like authorization codes exists before use—no more missing fields at runtime.
Tramli vs XState: which to choose?
XState for complex hierarchies and parallels; tramli for flat, provably correct data flows with build-time guarantees.
