Open-source alternatives to XNode

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

ShaderForge is a web-based GPU tool and visual GLSL shader editor. It serves as a node-based shader designer that allows users to construct programs for the graphics processor by connecting logic blocks in a directed acyclic graph rather than writing manual code. The tool functions as a technical art workflow bridge for creating game assets and surface materials. It provides a browser-based environment for real-time authoring, featuring instant GLSL compilation and live hot-reloading of GPU programs. The system converts visual graph connections into GLSL source code using abstract syntax tre

NaughtyAttributes is a collection of custom attributes for the Unity Editor inspector that allows for field validation, the exposure of non-serialized properties, and the addition of custom UI controls. It functions as an extension library to customize how fields are drawn and behave within the inspector interface without requiring the author to write custom editor scripts. The library provides tools for creating interactive elements such as buttons that execute specific methods, as well as specialized input controls like sliders and dropdowns. It enables the display of native properties and

Ryven is a flow-based programming framework and visual scripting editor for Python. It provides a node-based graphical interface for designing and executing logic by connecting discrete functional nodes to build executable data pipelines. The system functions as an extensible visual logic tool, allowing for the development of custom Python nodes and the integration of interactive GUI widgets to expand scripting capabilities. It includes a node graph engine that supports both visual editing and headless execution, enabling scripts to run without a graphical user interface. The platform covers

This project is a browser-based arcade game engine implemented in JavaScript. It provides a foundational framework for developing grid-based maze games, utilizing HTML5 canvas for immediate-mode rendering and structured data objects to define level layouts and item placements. The engine manages core interactive mechanics, including player navigation, collision detection, and real-time pathfinding for computer-controlled entities. It incorporates a state-machine game loop to handle transitions between active gameplay, paused states, and level progression, while tracking scores and item collec

AICommand is an LLM-powered editor controller and automation tool designed for the Unity Editor. It integrates large language models to translate natural language prompts into executable commands, allowing users to manipulate development environment settings and objects through text-based instructions. The system employs a text-to-action pipeline that uses LLM-based command mapping and reflection-based API discovery to resolve natural language input into specific editor functions. This process enables the execution of Unity editor functions by resolving string identifiers to code handles at r

UnityLibrary is a game engine asset library providing a collection of reusable scripts, shaders, and templates for development within the Unity engine. It functions as a boilerplate template set and an editor extension suite designed to automate common tasks and reduce repetitive setup. The project includes a collection of pre-built material shaders and visual effects that can be applied to surfaces without writing custom shader code. It also provides utility scripts and editor tools to enhance the native development workflow. The library covers project bootstrapping through the use of prede

This project is a game programming design patterns reference and software engineering guide. It provides a collection of architectural and structural patterns specifically applied to the development of video games, focusing on organizing game loops, entity component systems, and state management. The content is delivered as a digital book and markdown static site. It utilizes a static site generation workflow that transforms markdown source files and HTML templates into structured static pages for technical content publishing. The underlying system includes capabilities for static site compi

Thrive is a biological evolution simulation game and evolutionary sandbox where species evolve from single-celled organisms into complex civilizations. It serves as a multicellular life simulator and species progression engine, modeling the transition from microbes to industrial societies through natural selection and mutation. The project features a biological design tool and morphological editor for creating creature anatomy and tissue differentiation based on chemical principles. It includes a specialized environment for testing metabolic processes and designing organism shapes via cell sp

FXGL is a 2D game engine and development framework designed for Java and Kotlin. It provides a structured environment for building cross-platform desktop games, integrating a central game loop with an entity component system and a JavaFX-based scene graph for rendering. The toolkit distinguishes itself by providing a comprehensive suite of integrated libraries for game AI pathfinding, physics collision resolution, and multiplayer networking via TCP and UDP protocols. It includes specialized systems for adaptive user interface design using global stylesheets and a data-driven asset management

Amethyst is a data-driven game engine written in Rust for building high-performance 2D and 3D games. It is built on an entity component system architecture that decouples game state from logic to enable parallel processing and reusable code. The framework features a glTF 3D renderer for importing scenes and geometry using physically based materials. It also serves as a multiplayer game framework, providing network transport abstractions and state synchronization for real-time online experiences. The engine covers a broad range of capabilities, including hybrid 2D/3D rendering, asynchronous a

PocketFlow is a graph-based framework for designing and executing large language model operations and reasoning patterns. It serves as an orchestrator for building goal-oriented autonomous agents, multi-agent systems, and retrieval-augmented generation pipelines. The system is distinguished by its ability to coordinate autonomous AI agents that use shared memory and tools to solve complex goals, supported by a structured output engine that enforces schema-consistent responses. It utilizes graph-based workflow orchestration to manage sequences of model operations and supports supervisor-based

Entitas is a data-oriented Entity Component System framework for Unity. It is designed to separate game state into components and logic into systems, utilizing a data-oriented design to optimize CPU cache usage, memory usage, and processing speed. The framework includes a C# source code generator that automatically produces boilerplate classes, entity accessors, and context singletons to reduce manual coding. It also provides a Unity editor debugging tool for real-time runtime state visualization, system performance monitoring, and visual entity inspection. The system manages entity lifecycl

Dialogic is a dialogue editor and runtime system for the Godot engine that provides a complete framework for creating branching conversations with characters, animations, and state management. At its core, it functions as a branching narrative editor with visual and text-based timeline authoring, a character animation manager that handles portraits and scene positioning, a localization tool that exports timelines to CSV for translation, and an interactive framework that manages player choices, text reveals, voice lines, and dynamic text effects within conversations. What distinguishes this sy

ZenlessZoneZero-OneDragon is a game automation bot designed for Zenless Zone Zero. It functions as a combat automation script, an account management orchestrator, and an AI gameplay assistant to automate combat, daily quests, and character movement. The project utilizes image and audio recognition models to implement precision combat dodging and execute attack sequences. It employs pathfinding and recognition models for automated environmental navigation and interaction within game zones. The software provides broader capabilities for automating recurring daily tasks and resource collection.

Transitions is an object-oriented finite state machine library for Python. It provides a framework for managing valid states and the logic for moving between them, including implementations for asynchronous state machines and thread-safe state managers. The library supports hierarchical state machines that allow states to be nested to organize complex subtasks and logical contexts. It includes tools for generating visual diagrams of states and transitions to document machine logic. The project covers state management primitives such as lifecycle callbacks, conditional transition guarding, an

imove is a visual workflow orchestrator and domain-specific language designer. It provides a graphical canvas for mapping complex functional logic and designing operational workflows through a node-based interface. The system functions as a visual flowchart to code generator, converting logic diagrams into an executable domain-specific language for software development kits. It includes a custom logic node framework that allows for the integration of external plugins and the creation of custom functions to extend the available node library. The platform supports node-based logic design and r

This library is a finite state machine framework for JavaScript designed to manage application states and valid transitions. It provides a system for executing state changes with lifecycle hooks, conditional guards, and transition cancellation. The project is distinguished by its ability to inject state machine logic and transition capabilities directly into existing JavaScript class instances or objects. It also includes a visualization tool that exports state configurations into Graphviz DOT language for auditing system logic. The framework covers asynchronous transition execution and paus

This project is a real-time strategy game framework built for the Godot engine, providing a foundational template for developing isometric strategy titles. It offers a collection of reusable systems designed to accelerate the creation of competitive games, including support for both human and artificial intelligence participants. The framework distinguishes itself through a comprehensive suite of core mechanics tailored for the real-time strategy genre. It includes a dedicated fog-of-war system that obscures map regions based on unit line-of-sight, alongside isometric pathfinding and navigati

This project is a React-based framework for constructing interactive, node-based visual interfaces. It provides a platform for building canvases where users define, connect, and organize logical processes, data pipelines, or complex workflows through a graphical interface. By utilizing a modular component architecture, it enables the development of low-code environments, visual programming tools, and interactive diagramming applications. The framework distinguishes itself through a declarative approach where state changes automatically synchronize with the visual representation of nodes and e

Rete is a framework for building interactive, node-based visual interfaces and dataflow programming environments. It provides a core engine that processes directed graphs, allowing developers to define modular logic where nodes represent operations and connections represent the flow of data or control. By decoupling the graph logic from the user interface, the framework enables the creation of custom visual editors that can be integrated into various frontend component libraries. The project distinguishes itself through a highly extensible, signal-driven architecture that supports complex req

GoJS is a JavaScript diagramming library and canvas-based visualization engine used to build interactive flowcharts, organizational charts, and network diagrams. It functions as a data-driven framework that binds JavaScript data models to visual elements, enabling bidirectional synchronization between the underlying data and the graphical representation. The library features a comprehensive graph layout engine capable of automatically arranging nodes into trees, grids, circles, or force-directed layouts. It distinguishes itself through a template-based system for generating visual parts and a

Go-workflow is a lightweight library designed for defining and executing business process logic through a state-machine engine. It enables the automation of multi-step operations by managing task lifecycles, approval consensus, and the progression of processes through defined stages. The engine utilizes a data-driven approach where business processes are structured as serialized JSON arrays, allowing for the definition of routing paths and task sequences without the need for visual modeling tools. It supports hierarchical node nesting to represent complex, multi-stage workflows and employs co

Eino is an AI agent development kit and LLM application framework designed for building autonomous agents and orchestrating complex language model workflows. It serves as a multi-agent orchestration engine and workflow orchestrator, providing a graph-based execution model to route data between models, tools, and retrievers. The framework distinguishes itself through a robust set of multi-agent coordination patterns, including supervisor-led management, sequential flows, and autonomous reasoning loops like ReAct. It features advanced agent execution controls such as active turn preemption, che

go-diagrams is a Go visualization library and DOT language generator used to create system architecture diagrams. It implements a diagrams-as-code approach, allowing users to define system components, infrastructure dependencies, and data flows using Go source code. The library translates these code-based definitions into Graphviz DOT syntax, which is then processed by the Graphviz toolset to render final visual image assets. It supports mapping directional edges to illustrate dependencies and organizing related components into named clusters or subgraphs to represent architectural boundaries

BehaviorTree.CPP is a C++ library for designing task-switching logic and reactive behaviors using a hierarchical tree structure. It provides a framework for creating reactive logic systems that manage complex behaviors through an execution engine and a centralized data store for sharing state between nodes. The library decouples high-level behavioral logic from source code by using an XML parser to define tree morphology. It further extends its functionality through a dedicated visualizer for monitoring real-time execution states and a specialized bridge for integrating ROS2 actions and servi