Open-source alternatives to Transitions

XState is a statechart logic library and finite state machine framework used to model complex application behavior. It provides a system for defining states, events, and transitions to govern how a system responds to inputs through a formal schema. The project includes a visual state machine editor that allows for the design of state machine diagrams which automatically generate the corresponding logic and code. It implements an actor model to manage independent concurrent entities that communicate via asynchronous events to coordinate behavioral flows. The framework covers event-driven stat

This project is a Ruby library for defining and managing object lifecycles through states, events, and transition rules. It functions as a declarative workflow engine that enforces business logic by restricting attribute changes to predefined, valid paths within Ruby classes. The library distinguishes itself through deep integration with database persistence layers, allowing it to automatically synchronize state changes with data models, validation frameworks, and transaction management. It supports dynamic configuration, enabling the construction of lifecycle rules at runtime from external d

Zag is a headless UI state machine library that provides unstyled component logic to ensure consistent behavior across different rendering engines. It functions as a toolkit for modeling complex user interface interactions using statecharts, decoupling the underlying logic and accessibility attributes from visual styling. The library is framework-agnostic, utilizing specialized adapters to bridge its state machine logic with various JavaScript libraries such as React, Solid, Vue, and Svelte. This approach allows developers to maintain a single interaction model while applying any CSS or styli

Effector is a reactive state management library designed for building complex, event-driven applications. It functions as a data flow engine that models application logic as a directed acyclic graph, ensuring that state updates propagate automatically through interconnected nodes. By utilizing atomic state updates and declarative unit composition, the library maintains data consistency and provides a predictable execution model for managing application state. The project distinguishes itself through its framework-agnostic architecture, which decouples business logic from user interface implem

This project is a comprehensive collection of software design patterns implemented in Python. It serves as a reference for architectural, behavioral, creational, and structural patterns to guide the organization of Python applications. The collection covers behavioral strategies for managing object communication and state, creational techniques for controlling object instantiation, and structural methods for composing classes and objects into flexible hierarchies. It also includes architectural references for system-wide structuring, such as multi-tier architectures and blackboard models. Th

pyTelegramBotAPI is a Python framework and API wrapper designed for building bots that interact with the Telegram Bot API. It provides a toolkit for managing bot lifecycles through both synchronous and asynchronous request patterns. The framework is distinguished by a routing system that uses custom filters and middleware pipelines to direct incoming updates to specific handlers. It includes a finite state machine manager to track user progress through multi-step conversations and a retry-based system to handle server-side rate limiting. The library covers a broad range of capabilities, incl

This project is a library of C# software architecture examples and a reference for game programming patterns specifically implemented for the Unity engine. It provides a collection of Gang of Four and specialized game programming patterns to organize software components and improve code scalability. The implementation covers structural and behavioral patterns used to manage state and performance in real-time game simulations. It focuses on translating theoretical design patterns into working code to improve maintainability and system structure. The architecture includes patterns for action e

Glob is a pattern matching library for Go that compiles wildcard strings and file paths into optimized matchers for high-throughput string validation and filtering. It evaluates text and file paths against character sets, ranges, and alternatives to determine if candidate inputs fit specific criteria. The library parses raw glob strings into structured syntax nodes before translating them into bytecode instruction sequences upfront. This compilation process enables finite state machine evaluations and zero-allocation path matching during runtime execution, preventing garbage collection press

This project is a Substrate-based blockchain protocol implementation and a modular Rust blockchain runtime. It provides a framework for executing a distributed ledger protocol to maintain a synchronized network of nodes. The system features a peer-to-peer node implementation that manages decentralized communication and local key-value database storage. It includes a BFT-based consensus engine for coordinating block authoring and finality, as well as a WebAssembly-based runtime for isolated execution of state transitions. The protocol organizes domain-specific logic through a modular pallet a

Canopy is the official Go implementation of a blockchain node that runs a recursive network architecture, enabling new blockchains to launch as dependent layers that can later graduate into fully independent security roots. The project provides a hybrid consensus mechanism that combines Byzantine fault-tolerant Proof-of-Stake with Verifiable-Delay Functions, delivering instant finality while protecting against long-range attacks through trustless chain age verification. Validators secure multiple chains simultaneously through restaking, where a single bonded stake serves as collateral across t

Workflow-kotlin is a cross-platform state management and UI binding framework for Kotlin that models application navigation, background tasks, and screen rendering through composable, hierarchical state machines. The architecture drives application behavior by flowing immutable data downward to declarative user interfaces and routing user interactions upward through named event handlers. The library includes multiplatform target support for compiling shared code across operating systems, along with asynchronous operation execution that handles background tasks safely outside render passes. I

This is a Swift state management framework and application logic library designed for building applications with a single source of truth and unidirectional data flow. It provides a Redux-inspired architecture that separates business logic from side effects and user interfaces to ensure predictable application behavior across multiple screens. The framework focuses on modularity by allowing complex features to be decomposed into smaller, isolated components. This enables the development of UI-independent business logic that can be extracted into separate modules to improve compilation speed a

Hypothesis is a Python property-based testing library and data generation engine. It enables the discovery of edge cases and bugs by generating a wide range of randomized inputs based on defined strategies and shrinking complex failing examples to their smallest possible form. It also functions as a state machine testing framework to verify system behavior across sequences of interdependent operations. The project features a fuzzing integration layer that converts raw byte buffers from coverage-guided fuzzers into structured test cases. It includes a persistence mechanism to store and synchro

Gym is a reinforcement learning environment toolkit and agent simulation framework. It provides a standardized API and a universal communication interface that defines how learning agents interact with simulation environments through actions and observations. The project includes a benchmark environment suite and a diverse library of pre-configured simulation worlds, including physics engines and classic control tasks. It enables the creation of custom simulation environments to train agents in specific operational scenarios while ensuring reproducibility across different learning algorithms.

Reth is a modular, high-performance Ethereum execution layer client written in Rust. It serves as a full Ethereum node that syncs, validates, and serves blockchain data, functioning as an archive node implementation, a high-throughput RPC node server, and a snapshot sync tool. The project is built around a modular component architecture that allows assembling custom node behavior by swapping independent Rust crates for consensus, execution, mempool, and networking. The client distinguishes itself through a staged sync pipeline that downloads headers and bodies online before processing the res

This project provides the formal technical specifications and reference logic for the Ethereum proof-of-stake consensus layer. It defines the standards for block production, state transition rules, and the beacon chain logic required to ensure consistent network agreement. The implementation covers specialized mechanisms for chain security and efficiency, including fork-choice algorithms for canonical chain determination, committee-based signature aggregation, and KZG-based blob commitments for data availability. It also specifies the protocols for light client synchronization using sync comm

react-waypoint is a React component and viewport tracking tool that executes functions based on the visibility of a DOM node within a scrollable area. It monitors when elements enter or leave the browser viewport or a specified scroll container to trigger callbacks. The project enables the implementation of infinite scrolling, asset lazy loading, and scroll-triggered animations. It allows for custom scroll container definitions and viewport boundary configurations using offsets to determine exactly when events fire. The tool provides element position tracking and visibility monitoring for bo

Loro is a conflict-free replicated data type (CRDT) framework and collaborative state engine designed for building real-time collaborative applications. It provides a distributed data synchronizer that enables multiple users to edit shared documents and complex nested structures—such as maps, lists, trees, and counters—with automatic state convergence without requiring a central server. The project distinguishes itself through a versioned document store that supports branching, forking, and merging via a directed acyclic graph of causal operation history. It enables advanced version control c

PlantUML is a text-to-diagram generator that translates human-readable markup into structured graphical representations. It functions as a diagram-as-code tool, allowing users to create and maintain technical documentation, architectural models, and flowcharts by decoupling diagram content from visual layout. The project distinguishes itself through a comprehensive rendering pipeline that processes domain-specific markup into various output formats, including vector and raster graphics. It utilizes a graph-based layout engine to calculate spatial positioning, while a declarative styling layer

re-frame is a functional framework for building single-page applications in ClojureScript. It provides a centralized, immutable database that serves as the single source of truth for the entire application state, enforcing a strict unidirectional data flow where events trigger state transitions and subsequent view updates. The framework distinguishes itself through a reactive signal graph and an interceptor-based middleware pipeline. By treating application logic as a sequence of data-driven events and declarative side effects, it decouples business logic from the view layer. This architectur

Boost is a collection of portable, high-performance source libraries that extend the C++ standard library. It provides a wide range of reusable components, data structures, and algorithms designed to add capabilities to the base language across different platforms. The project is distinguished by its extensive focus on compile-time template metaprogramming and generic programming. It implements advanced architectural patterns such as policy-based design, concept-based type validation, and the use of SFINAE for conditional template resolution to minimize runtime overhead. The library covers a

Sylar is a high-performance C++ asynchronous server framework and event-driven network library. It functions as a coroutine scheduler and HTTP server implementation designed to build network services using non-blocking I/O. The project distinguishes itself through a system call interceptor that hooks blocking socket and sleep APIs, transforming synchronous operations into non-blocking asynchronous events. It employs a user-space threading system to distribute lightweight tasks across a worker thread pool to maximize CPU utilization. The framework covers a broad range of networking and system

UFO is a multi-device task orchestrator and LLM agent orchestration framework designed to decompose natural language requests into executable task graphs. It functions as a cross-platform UI automation tool capable of performing interactions on Windows and mobile devices while routing tasks to distributed agents based on their hardware and software capabilities. The system is distinguished by its RAG-enhanced agent architecture, which integrates external documentation and previous execution traces to improve decision-making. It employs a hybrid UI detection approach that combines computer vis

This project is a comprehensive collection of computer science implementations and an algorithm tutorial repository. It serves as a study guide and reference for competitive programming, providing executable code examples that demonstrate fundamental algorithmic problem solving and mathematical computation. The library covers a wide range of specialized domains, including cryptography and security primitives, lossless data compression techniques, and computational geometry for spatial analysis. It also features implementations of machine learning models, linear algebra operations, and formal

Sensitive-lexicon is a sensitive word detection service and content moderation tool designed to identify prohibited text. It utilizes a curated lexicon of thousands of categorized terms and a fuzzy matching text scanner to detect restricted words and phrases. The project features specialized filters for Chinese language content across political, social, and adult domains. It supports approximate string matching to identify terms that use noise characters or whitespace to evade standard keyword filters. The system includes a network interface for hosting the detection service, allowing for re

Sanic is an asynchronous Python web framework designed for building high-performance APIs and services. It operates as a production-ready ASGI web server, utilizing a non-blocking event loop to handle concurrent requests and maximize throughput. The framework is built to support scalable architectures, offering built-in worker process management to distribute traffic across available CPU cores. What distinguishes Sanic is its focus on modularity and developer-centric tooling. It features a blueprint-based system for organizing complex applications into pluggable components, alongside a robust