State management library

Refluxjs is a state management library designed to implement a unidirectional dataflow architecture. It manages application state through a strict cycle of actions and stores to prevent unpredictable update loops. The library coordinates asynchronous operations by managing event streams and triggering related success or failure actions. It also provides a global state registry that tracks store states via unique identifiers, enabling deep cloning for persistence and time-travel debugging. Its capability surface covers centralized state management, including the creation of data stores and de

Redux is a predictable state container designed to manage global application data through a centralized store. It operates on a unidirectional data flow architecture where state transitions are triggered by dispatching action objects, which are then processed by pure reducer functions to produce a new, immutable state tree. This approach ensures that application data remains consistent and traceable across the entire component hierarchy. The library distinguishes itself through a functional pattern that relies on pure functions for state logic and a middleware-based extension system. This mid

Van is a reactive JavaScript UI framework designed for building user interfaces with state binding and automatic DOM updates without a virtual DOM. It functions as a buildless frontend framework, allowing the creation of reactive applications using standard JavaScript functions that run directly in the browser without a compilation step. The framework includes a reactive state manager that uses proxy-based objects to track dependencies and trigger targeted UI updates. It provides a server-side rendering tool for generating static HTML and a corresponding client-side hydration process to attac

Redux-Observable is a functional middleware for Redux that treats action streams as observables to manage complex asynchronous side effects and timing. It acts as an asynchronous action orchestrator, transforming streams of Redux actions into new actions through pipelines of observable-based side effects to coordinate application state changes. The project allows for the dynamic loading, injection, and replacement of side-effect streams at runtime. This enables the addition of asynchronous task handlers without requiring a full application restart, supporting code splitting and lazy loading o

ReSwift is a unidirectional data flow framework for Swift applications that centralizes state management within a single store. It ensures predictable and traceable updates by requiring all state modifications to occur through explicit actions processed by reducer functions. The library includes a state time travel debugger that records and replays sequences of actions to reload or rewind the application state. It also provides an asynchronous action dispatcher to handle side effects and network requests while maintaining synchronized state updates. The framework covers a broad surface of st

Vuex is a centralized state management library for Vue.js applications. It provides a single source of truth for application data, ensuring consistent state across a component tree through a reactive data store. The system organizes the global state tree into independent, namespaced modules to prevent naming collisions and maintain code organization. It distinguishes between synchronous mutations for predictable state transitions and asynchronous actions for handling complex operations. The library includes cached getters for derived state, store lifecycle hooks for mutation interception, an

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

Valtio is a proxy-based state management library and reactive state engine that provides a mutable state store. It allows application state to be updated through direct object mutations rather than immutable patterns, using JavaScript proxies to track changes and trigger updates. For React applications, it includes a synchronization hook that ensures components re-render only when the specific properties they access are modified. The system supports reactive data derivation through computed properties that automatically update when their underlying dependencies change. It maintains reactivity

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

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

This project is a declarative framework for building reactive user interfaces by embedding logic directly into HTML markup. It functions as a lightweight state container that tracks data changes and automatically synchronizes the document object model with the underlying application state. By utilizing proxy-based observation, it ensures that interface updates occur precisely when reactive properties are modified. The framework distinguishes itself by allowing developers to define interactive behavior through custom attributes rather than external scripts. This approach enables the compositio

This project is a comprehensive collection of modular, reactive functions designed to streamline the development of user interfaces. It serves as a toolkit for managing application state, wrapping native browser hardware and system features, and encapsulating common logic patterns into reusable units. By binding asynchronous data sources, browser events, and system properties to component state, it provides a unified framework for building interactive web and desktop applications. The library distinguishes itself through its focus on composition and lifecycle management, allowing developers t

Eve is a domain-specific language IDE and integrated logic editor that combines a custom programming language with a dedicated editor to define application logic and state. It functions as a reactive state management system that monitors state variables and automatically triggers functional responses. The environment features an integrated runtime-editor loop that couples the language execution environment with the text editor to accelerate the development cycle. This setup enables the definition of software behavior and state transitions using an embedded domain-specific language. The proje

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

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

Livestore is a reactive state management framework that utilizes a local SQLite database to store and synchronize application data. It provides an event-sourced state store that processes typed events through materializer functions to derive and persist application state. The framework implements offline-first data synchronization using a push-pull engine and append-only event logs to maintain consistency between clients and servers. It includes a real-time presence system for tracking user activity and shared session status across connected clients. The system covers a broad capability surf

Nano Stores is a framework-agnostic state management library that uses a system of small, independent atomic stores to synchronize data across different JavaScript UI frameworks. It provides a reactive state container designed to minimize unnecessary component re-renders by decoupling application state into independent stores. The library features specialized synchronizers for real-time distributed state using WebSockets with conflict-free replicated data types, as well as a browser storage persistor for maintaining state across multiple open tabs. It utilizes adapter-based integration to map

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

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

Arrow-js is a reactive UI framework and server-side rendering system designed for building agentic interfaces. It functions as a reactive state manager and isomorphic routing engine, enabling the creation of web applications that utilize tagged template literals for efficient DOM updates. The project distinguishes itself by incorporating a WebAssembly code sandbox, which allows untrusted or AI-generated code to execute within a secure virtual machine to render interfaces without accessing the host DOM. It further enables agentic UI development by allowing AI agents to dynamically generate vie

Store.js is a client-side state persistence library and web storage abstraction layer. It provides a consistent browser key-value storage wrapper that manages the persistence of application state across sessions using the most capable available local storage mechanism. The engine is extensible, allowing for the integration of custom storage backends and plugins to modify how data is read and written. It functions as a reactive web storage manager, monitoring specific keys to trigger notifications when stored values are updated. The library handles automatic data serialization for complex typ

SWR is a data fetching library that provides a collection of hooks for managing remote data synchronization, caching, and state updates in web applications. It employs a declarative approach to handle complex network request lifecycles and dependency chains, ensuring that client-side application state remains consistent with server data through automatic revalidation and background updates. The library distinguishes itself through a reactive cache layer that automatically synchronizes local state with remote sources based on component lifecycle events. It features event-driven revalidation, w

Data-client is an asynchronous state management library designed to synchronize server data with frontend applications. It functions as a normalized cache manager that maps complex API responses into structured, relational entities, ensuring data consistency across the entire application. By providing a unified communication layer, the library supports both REST and GraphQL, allowing developers to bind network data directly to user interface components through declarative hooks. The library distinguishes itself through a robust architecture for optimistic user interface development, where loc

This project is a custom implementation of the Model-View-ViewModel pattern designed to replicate the core reactivity and template parsing of the Vue framework. It functions as a data-binding engine, a reactive state manager, and a custom template compiler. The framework employs a system for synchronizing model state with DOM elements through property interception and an observer pattern. It uses a parser to scan DOM elements for directives, replacing placeholders and binding data to view nodes to achieve two-way data synchronization. The system covers reactive data binding and the developme

Panel is a Python data application framework used to build interactive dashboards and reactive user interfaces by connecting data visualizations, widgets, and callbacks. It functions as a reactive UI library that synchronizes application state with interface updates based on user interactions. The project distinguishes itself by offering multiple execution models, including a FastAPI-based web application server for scalable session management and a WebAssembly compiler that enables Python applications to run directly in the browser without a backend server. It also includes a specialized too

Get is a framework for Flutter that provides a comprehensive toolkit for dependency injection, internationalization, route management, and reactive state management. It includes a UI utility kit for handling themes, adaptive layouts, and the display of overlays such as snackbars and dialogs. The framework is distinguished by its ability to perform navigation and overlay management without requiring a build context. It also features a dependency injection container that manages the memory lifecycle of controllers and services, and a localization system that maps keys to strings to update appli

Legend-State is a reactive state management library for JavaScript applications that provides a centralized container for application data. It utilizes a fine-grained reactivity engine to track state access automatically, allowing developers to update and retrieve data without the need for boilerplate patterns like reducers, actions, or dispatchers. The library distinguishes itself through its hierarchical, path-based state addressing and proxy-based dependency tracking. By isolating state dependencies, it ensures that user interface updates are triggered only for the specific components that

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

Little State Machine is a lightweight state management library for React applications that provides a centralized data store for managing shared application information. It utilizes a context-based provider pattern to distribute state across the component tree, ensuring consistent data access without the need for manual property drilling. The library distinguishes itself through built-in support for automatic browser storage persistence, which synchronizes the in-memory state with local or session storage to maintain data continuity across page refreshes. It also incorporates middleware-drive

Declarative, incremental state management library

A Blazor State management library by TimeWarp.

RxJS and ImmutableJs powered state managment Angular apps. Inspired by NgRx.

Hyperapp is a lightweight JavaScript framework for building web applications. It functions as a declarative state management system that synchronizes the user interface with a centralized application state. The framework utilizes a virtual DOM to render user interfaces and reconcile changes to the browser display. It employs a subscription model to synchronize external web APIs and asynchronous events with the global state. The system manages data through a single-state-tree architecture, where updates are handled via discrete actions and pure functions. This approach ensures that the view u

React Redux is a global state management bridge and a set of bindings that connect React components to a Redux state store. It serves as a communication layer and state store connector, allowing a declarative user interface to synchronize with a centralized source of truth. The library enables the synchronization of shared global state across an application by providing mechanisms to read state and dispatch actions directly from the view layer. It ensures predictable state transitions by bridging the gap between UI components and the Redux state container. The project covers core capabilitie

Simple state management in Angular with only Services and Signal.