•        138

AsmL is the Abstract State Machine Language, developed Microsoft Research. It is an executable specification language based on the theory of Abstract State Machines. This CodePlex project comprises an AsmL compiler that targets .NET code.



Related Projects

ASML - Write action script 3 in XML markup's . ASML class is decoder for specify XML tags .

Write action script 3 in XML markup's . ASML class is decoder for specify XML tags .


Rework of popular MinimalComps library , upgraded for data binding , relative resizing , ASML builder and more ...

Spring Statemachine - Framework for application developers to use state machine concepts with Spring

Spring Statemachine is a framework for application developers to use state machine concepts with Spring applications. Hierarchical state machine, Usage of triggers, transitions, guards and actions, Type safe configuration adapter, Distributed state machine based on a Zookeeper, State machine event listeners and lot more.

state-machine - Finite state machine class generator for java, exports graphml, supports immutability!

Generates java classes to handle state transitions based on a state machine defined with type safety in java. Supports immutability (though is not opinionated in the sense that if you want to mutate your objects you can).Consider a microwave. If you were going to write the control system for a microwave you'd find it's a natural candidate for a state machine (actually all programming is working with state machines but we are going to work with one quite explicitly). We are going to work with a very simple microwave design (one you'd be crazy to buy in the shops!) just to demonstrate state diagrams.

StatefulJ - Event Driven Finite State Machine (FSM)

StatefulJ is a lightweight, open source Java Event Driven Finite State Machine(FSM) and a complete Spring Data based framework which lets you easily define and integrate State Machines into your Applications. It is simple, dependency free, in memory implementation of an FSM with support for concurrency and non-deterministic transitions.

SMC - The State Machine Compiler

SMC takes a state machine stored in a .sm file and generates a State pattern in 14 programming languages. Includes: default transitions, transition args, transition guards, push/pop transitions and Entry/Exit actions.

Tendermint - Tendermint Core (BFT Consensus) in Go

Tendermint Core is Byzantine Fault Tolerant (BFT) middleware that takes a state transition machine - written in any programming language - and securely replicates it on many machines.

Finite State Machine Editor

A Finite State Machine Editor, written on QT. It allows to draw Finite State Machine with easy GUI and store it in XML file. There are Finite State Machine Compilers to translate this description to source code (technique like QT's UIC uses).

Simple State Machine

A simple state machine implementation written to replace WF in one of our projects. The interesting aspect of this library is that it comes with a DSL written in boo for quick and easy configuration and management of state machine definitions.

fysom - Finite State Machine for Python (based on Jake Gordon's javascript-state-machine)

Finite State Machine for Python (based on Jake Gordon's javascript-state-machine)

yaraft - Yet Another RAFT implementation

yaraft is a C++11 port of etcd/raft, which is a widely proven Raft library written in Go. Raft is a well-known distributed consensus algorithm. It's a practical solution designed for understandability, without sacrificing performance and fault-tolerance comparing to Paxos.etcd/raft features at its minimalistic design that only the core Raft protocol is implemented. No RPC, no WAL storage, no multi-threaded environment. It has nothing more than a pure state machine, so that we can test it in a deterministic way. For state machines with the same state, the same state machine input should always generate the same state machine output.


Smach is an open-source Scala library designed to support creation of functional, composable, streamable and recoverable state machines. Smach state machines can be composed together to form larger state machines or connected together to form a processing pipeline plan that can be run to produce a final value. Smach state machines also support a generic error recovery system (by way of the Halted state) that may be used to report errors encountered during processing by any composed or connected

Reactive State Machine

Reactive State Machine is a State Machine implementation based on Reactive Extensions. It plays nicely with the Visual State Manager of WPF.

micromachine - Minimal Finite State Machine

Minimal Finite State Machine.There are many finite state machine implementations for Ruby, and they all provide a nice DSL for declaring events, exceptions, callbacks, and all kinds of niceties in general.

Copycat - A novel implementation of the Raft consensus algorithm

Copycat is a fault-tolerant state machine replication framework. Built on the Raft consensus algorithm, it handles replication and persistence and enforces strict ordering of inputs and outputs, allowing developers to focus on single-threaded application logic. Its event-driven model allows for efficient client communication with replicated state machines, from simple key-value stores to wait-free locks and leader elections. You supply the state machine and Copycat takes care of the rest, making it easy to build robust, safe distributed systems.

go-fsm-example - An example FSM implementation in Go

The idea is simple, each state function returns the next state.```go// stateFn represents the state of the machine// as a function that returns the next state.type stateFn func(*fsm) stateFn```Then each state is defined as a function that receives a `*fsm` and return a `stateFn````gofunc idleState(f *fsm) stateFn {f.code = ""fmt.Printf("Enter code: ")return readState}```In this example I'm creating a fsm that verify some secret code.To represent the `done` state a `stateFn` must return `nil` and

OpenFst Library for constructing weighted finite-state transducer

OpenFst is a library for constructing, combining, optimizing, and searching weighted finite-state transducers (FSTs). Weighted finite-state transducers are automata where each transition has an input label, an output label, and a weight. FSTs have key applications in speech recognition and synthesis, machine translation, optical character recognition, pattern matching, string processing, machine learning, information extraction and retrieval among others.

automaton - Friendly state machines for python.

Friendly state machines for python. The goal of this library is to provide well documented state machine classes and associated utilities. The state machine pattern (or the implemented variation there-of) is a commonly used pattern and has a multitude of various usages. Some of the usages for this library include providing state & transition validation and running/scheduling/analyzing the execution of tasks.

Finite State Machine (FSM)

This library is an implementation of an extensible dynamic configurable finite state machine (FSM). The configuration of the state machine is not compiled, but loaded at the runtime from a file or created by application.

Windows Workflow (State Machine), Duplex WCF Service, WPF and Silverlight

This Visual Studio solution demonstrates a complex implementation, which is a simple order process system, utilizing Windows Workflow (state machine), duplex WCF services(TCP duplex and Silverlight polling), WPF and Silverlight.