Open-source alternatives to Mobx

Solid is a declarative JavaScript framework for building user interfaces through fine-grained reactivity. By utilizing a compile-time template transformation process, it converts JSX into direct DOM manipulation instructions, eliminating the need for a virtual tree. This architecture allows the framework to track dependencies at the individual element level, ensuring that state changes trigger surgical updates to the interface. The framework distinguishes itself through its isomorphic rendering pipeline, which shares reactive logic across server and client environments to support both initial

Signals is a reactive state management library and fine-grained reactivity engine. It functions as a dependency-tracking state manager that maps relationships between values to ensure derived data and user interface elements remain synchronized. The library distinguishes itself through direct-to-node DOM binding, which allows state to update specific text nodes in the browser without triggering a full component render cycle. It employs a runtime dependency graph and atomic batching to group multiple state modifications into single notification cycles, reducing redundant executions. The syste

Pinia is a state management library for Vue applications that provides a centralized, type-safe architecture for organizing reactive data. It utilizes a modular store pattern, allowing developers to define independent, reusable state containers that manage shared application data, computed getters, and executable actions. The library distinguishes itself through a flexible definition model that supports both functional setup patterns and traditional object-based structures. It features a plugin-based extension architecture that enables developers to hook into the store lifecycle for custom fu

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

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

Leptos is a full-stack Rust web framework designed for building reactive applications that share logic and types between the server and the browser. It provides a comprehensive toolkit for developing web interfaces where specific DOM nodes update automatically in response to changes in underlying reactive signals, rather than re-rendering entire component trees. The framework distinguishes itself through a fine-grained reactivity model that tracks dependencies at the individual data point level. It utilizes compile-time template transformation to convert declarative HTML-like syntax into opti

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

This project is a state management framework for Angular applications that provides a predictable state container. It implements a Redux-style architecture using a centralized store, managing global and local application data through an observable-based data flow of actions and reducers. The framework includes a specialized entity management tool for organizing and synchronizing server-side data collections within client-side stores. It also provides a reactive store system that integrates state updates with Angular signals for change detection and includes debugging mechanisms for time-trave

Apollo Client is a GraphQL client library and data fetching framework used to request data from a GraphQL server and synchronize that state within a frontend application. It functions as a remote state manager and a local state management tool, allowing developers to define client-side schemas and resolvers for data that does not reside on a remote server. The project features a normalized GraphQL cache that identifies objects by ID to ensure referential equality and consistent data updates across different queries. It also includes a GraphQL API mocking tool to simulate server responses and

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 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

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

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

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

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

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

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

Immutable.js is a library of persistent data structures and a functional state management toolkit. It provides a collection of immutable objects and arrays that prevent direct mutation to ensure predictable state management in JavaScript applications. The library utilizes structural sharing to efficiently create new versions of data without full copying and implements lazy sequence processing to chain data transformations that execute only when values are requested. It also supports batch mutation processing, allowing multiple changes to be applied to a temporary mutable copy before returning

Immer is an immutable state management library used to create new versions of data structures. It allows the production of new state by mutating a temporary draft instead of using manual object spreading. The project implements structural sharing to reuse unchanged parts of a data tree between versions, which reduces memory consumption. It also functions as a JSON patch generator to calculate and output the differences between two state versions. To ensure data integrity, the library includes a state mutation protector that freezes data structures to detect and prevent accidental modificatio

Relay is a GraphQL client framework and state manager used for building data-driven applications. It functions as a declarative data fetching layer and a GraphQL compiler that transforms declarations into optimized runtime code with automatic type generation. The framework distinguishes itself through a build-time compilation process that generates optimized queries and a data masking system that prevents components from accessing undeclared data. It employs a normalized client-side cache to maintain consistency across entities and an optimistic update mechanism to provide immediate interface

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

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

Ripple is a full-stack TypeScript web framework and reactive UI library used for building interfaces with server-side rendering. It organizes user interfaces into a hierarchy of reusable, scoped components with built-in state management and client-side hydration. The framework is distinguished by its fine-grained reactivity, which updates specific DOM elements without requiring full component re-renders. It integrates server-side logic and client-side components within a single TypeScript codebase, enabling a unified full-stack development workflow. The system covers a broad range of capabil

Riverpod is a reactive state management framework for Dart that manages application state through providers which automatically track dependencies and rebuild dependents when values change. It functions as an asynchronous data caching library, caching results of async operations and exposing loading, error, and data states to widgets without manual future handling. The framework includes a provider composition system that combines multiple providers into derived values that recompute automatically when any dependency changes, along with code generation for state providers that reduces boilerpl

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

Observer-util is a reactive state management library that leverages ES6 proxies to automate dependency tracking and synchronization between data and application logic. By wrapping plain data structures in transparent proxies, the library monitors property access and mutations to trigger associated functions automatically whenever the underlying state changes. The library distinguishes itself through its granular control over the reactive lifecycle and execution flow. It provides mechanisms to decouple data change detection from reaction execution, allowing developers to implement custom sched