Open-source alternatives to Little State Machine

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

unstated-next is a lightweight state management library for React that shares state and logic across components. It functions as a tool to transform custom hooks into shared state containers, providing a minimalist approach to synchronizing data without the use of complex external state stores. The project uses a provider-consumer pattern to decouple state definition from its usage. It wraps custom hooks into context containers to reduce manual boilerplate, allowing state and methods to be broadcast from a central provider to deeply nested child components. The system supports state containe

React Cursor is a state management library for React applications that maintains centralized application state through hierarchical cursor paths and immutable data modeling. It stores all application data in a single root location, keeping downward component trees stateless and predictable. The library enables path-based cursor refinement, allowing developers to drill down through recursive data structures to create localized child cursors pointing to specific nested substructures. Modifications are propagated upward by generating new immutable state trees using pure function updates applied

React-Redux provides the official bindings that connect a Redux state container to a React user interface. It functions as a state management integration and UI state connector, enabling the synchronization of a centralized data store with a component tree. The library ensures a predictable UI state flow by implementing a unidirectional data path between the interface and the state container. It allows components to read global state and dispatch actions to trigger updates, maintaining a single source of truth across the application. The project handles state synchronization through a combin

Easy-peasy is a React state management library and typed framework that provides a centralized store for managing global application state. It functions as an immutable state store and an async state orchestrator, ensuring end-to-end type safety for state definitions, actions, and derived values. The library distinguishes itself by converting direct mutation syntax into immutable updates to simplify the management of nested data. It includes a mechanism for persisting the state tree to storage and rehydrating it during the application boot process, with the ability to suspend the user interfa

Constate is a global state management tool for React designed to minimize unnecessary component re-renders. It functions as a state manager and optimization tool that utilizes specialized contexts to organize shared data across a component tree. The library distinguishes itself through a state-slicing provider pattern, which splits global state into multiple contexts to isolate data dependencies. It includes a state selector system that allows components to extract specific slices of global state, ensuring interface updates only occur when the selected data dependencies change. The project c

This project provides a React hook for synchronizing component state with browser storage, ensuring data persists across page reloads and browser sessions. It is designed to manage persistent application state while providing hydration-safe initialization to prevent mismatches during the transition from server-side rendering to client-side execution. The library distinguishes itself by including a fallback manager that detects when browser storage is inaccessible, automatically switching to an in-memory state to maintain application continuity. It also supports cross-tab synchronization by li

mobx-react is a library that provides state bindings to connect React components to MobX observable state. It functions as a component state synchronizer, ensuring that user interface elements automatically re-render only when the specific observed data they consume changes. The project enables a decoupled state architecture by moving business logic and domain state into standalone stores, separating data management from the React component tree. It facilitates global state distribution across deep component hierarchies using providers and context to avoid manual prop drilling. The library c

MobX State Tree is a structured, tree-based state management library for JavaScript applications that combines typed model definitions with reactive snapshots and patch-based change tracking. It provides a reactive state container with runtime and compile-time type safety, where application state is defined as a tree of typed models with collocated actions, computed views, and lifecycle hooks for predictable state mutations. The library is built around an action-centric mutation model that encapsulates all state changes within named functions that directly modify the tree, supported by genera

react-use is a collection of reusable state and effect hooks for managing common logic in React applications. It serves as a comprehensive library for implementing state management patterns and wrapping various browser APIs into consistent hook interfaces. The project provides a specialized toolkit for DOM interaction and browser API integration, allowing components to track element dimensions, manage cookies, and monitor hardware sensors. It includes a suite of animation and timing utilities for physics-based numeric interpolation and frame-synced state updates. Beyond basic state managemen

Zustand is a state management library that provides a centralized store for managing shared application data. It functions as a reactive container that connects application state to components, allowing them to subscribe to specific slices of data and trigger updates automatically. By utilizing selector-based data access and immutable state updates, the library ensures that components only re-render when their observed data changes, maintaining a predictable and efficient data flow. The library distinguishes itself through a pluggable, middleware-based architecture that allows for the extensi

Violentmonkey is a userscript manager extension and JavaScript injection framework. It allows users to install and manage custom scripts and CSS to modify the behavior and appearance of websites based on metadata-driven trigger conditions. The project functions as a cloud-synced script manager, backing up and synchronizing scripts across different devices using external cloud storage services. It also serves as a cross-origin request bridge, providing a communication layer that enables scripts to bypass the same-origin policy to fetch data. The tool covers a broad range of browser automation

This project is a comprehensive interview preparation guide and technical study resource for React. It functions as a frontend engineering curriculum and coding challenge bank designed to help developers master the internal mechanics, patterns, and core fundamentals of the React ecosystem. The resource distinguishes itself by providing a curated collection of technical interview questions, conceptual quizzes, and expert solutions. It includes a bank of coding challenges that can be solved in a browser-based environment with automated test cases and real-time rendering, as well as research int

Redux Persist is a state management utility designed to maintain application data across sessions by synchronizing state with local storage. It functions as a middleware-based engine that automatically saves and restores application state, ensuring that user sessions remain intact after page refreshes or application restarts. The library distinguishes itself through granular control over the persistence lifecycle and data structure. It supports recursive state tree partitioning, allowing developers to apply distinct storage configurations and filtering rules to specific branches of the applic

This project is a functional programming compiler and JavaScript transpiler that transforms a statically typed language into optimized JavaScript for web browsers. It serves as a frontend architecture framework, providing a static type system and a package manager that enforces semantic versioning. The compiler uses a type-checking engine with automatic type inference to prevent runtime errors and guide code refactoring. It implements a structural pattern for managing application state and rendering user interfaces through a virtual DOM, utilizing immutable data and purity-based state transit

This project is a reactive, offline-first NoSQL database engine designed for JavaScript applications. It provides a robust framework for managing application state by synchronizing data across browsers, mobile devices, and server-side runtimes. By treating local storage as the primary source of truth, it enables applications to remain functional without network connectivity, automatically reconciling changes with remote backends once a connection is restored. The database distinguishes itself through a modular architecture that supports cross-environment synchronization and high-performance d

Jotai is a state management library for React applications that utilizes an atomic model to handle data. It organizes application state into small, independent units called atoms, which automatically track dependencies and trigger granular updates to components. By building state through these composable primitives, the library ensures that only the necessary parts of an application re-render when data changes. The library distinguishes itself through its flexible approach to state composition and asynchronous data handling. It integrates promises directly into the state model, allowing devel

Effector is a reactive state management library and data flow orchestrator designed for building complex, event-driven applications. It models application logic as a directed acyclic graph, where state updates and asynchronous side effects propagate automatically through declarative pipelines. By decoupling business logic from user interface layers, it allows developers to maintain state in independent containers that communicate via standard interfaces, ensuring the system remains framework-agnostic. The library distinguishes itself through its robust support for isolated execution scopes, w

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

jscamp is a full-stack web development and education project focused on mastering JavaScript, TypeScript, and AI integration. It provides a structured curriculum and interactive exercises covering language fundamentals, frontend engineering, and backend API development. The project distinguishes itself through the implementation of autonomous AI agents capable of complex task automation, such as modifying files, managing servers, and executing API calls. It includes advanced AI development tools for conversational querying, real-time code suggestions, and automated repository analysis to gene

React is a JavaScript library for building user interfaces through the composition of modular, self-contained components. It employs a declarative programming model where developers describe the desired visual state, and the library automatically manages the underlying document updates and state synchronization. By utilizing a virtual representation of the document, it calculates and applies minimal changes to the browser, ensuring efficient rendering even in complex applications. The library distinguishes itself through a sophisticated scheduling system that manages rendering work in increme

This project is an AI-powered visual canvas and collaborative whiteboard framework. It functions as a customizable vector drawing engine and a tool for converting hand-drawn interface sketches and wireframes into functional code using artificial intelligence. The system distinguishes itself through the integration of AI agents that can read, modify, and generate visual diagrams directly on the canvas. It also provides a node-based workflow editor for building automation pipelines and data processing flows by connecting multimodal components. The platform covers a broad range of capabilities,

TinyBase is a reactive data store and in-memory relational database designed for client-side state persistence. It serves as a local-first sync engine that merges distributed state using conflict-free replicated data types and logical clocks to ensure deterministic data convergence. The project features a schema validation library that converts external definitions from tools like Zod, Yup, and TypeBox into type-safe store definitions. It provides an infrastructure for real-time collaborative editing, utilizing synchronization with Automerge, Yjs, and PartyKit to maintain consistent state acr

This library provides a collection of hooks for integrating GraphQL data operations into functional components within the Apollo Client ecosystem. It functions as a state management tool that synchronizes remote server data with local component state, ensuring consistent data representation across the user interface. The project distinguishes itself by enabling server-side rendering through a framework of utilities that pre-fetch data and resolve component trees to deliver fully populated HTML. It utilizes a provider-based pattern to inject the data client into the component tree, allowing ne

Pinia is a global state management store designed specifically for Vue applications. It serves as a centralized system for storing and synchronizing shared application data across multiple components using the Vue Composition API. The project provides a type-safe state store with native TypeScript support, utilizing type-inferred schemas to ensure consistency and prevent runtime errors for both application data and store actions. The architecture is built around modular store containers that can be registered dynamically. This system integrates with Vue reactive primitives and includes devel

React Easy State is a state management library for React that utilizes the observable store pattern to synchronize user interface components with application data. It employs ES6 proxies to wrap plain JavaScript objects, enabling the system to monitor data mutations and automatically trigger component re-renders whenever accessed properties are modified. The library distinguishes itself through a transparent reactive system that eliminates the need for explicit data binding or boilerplate code. By tracking dependencies during the rendering process, it ensures that components only update when

d2-admin is an admin dashboard framework used to build back-office management interfaces. It provides a set of pre-configured layouts and themeable components, including foldable sidebars and draggable grid systems, to facilitate system oversight and control. The framework is distinguished by its multi-tab administration interface, which allows users to switch between pages and reorder tabs via drag and drop. It also features a dynamic translation system for multi-language interface localization and a dedicated toolset for tabular data management, enabling the import and export of data via CS