Projects sharing features with Redux Toolkit

Rematch is a Redux state management framework and model orchestrator designed to organize application state into cohesive units. It functions as an asynchronous state workflow manager that bundles reducers and side effects into modular models to reduce the boilerplate typically required for Redux implementations. The framework provides an extensible plugin architecture for injecting custom behavior and configuration into the store lifecycle. It supports a multi-store application architecture, allowing for the creation and management of several independent state containers within a single appl

React is a JavaScript library for building user interfaces based on a component-driven architecture and unidirectional data flow.

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

fish-redux is a Flutter application framework and state management library that implements a Redux-based workflow. It provides a centralized state container and uses reducers and actions to maintain a single source of truth, ensuring data consistency across application screens and components. The framework includes a state-to-UI connector that transforms raw state data for display and automatically updates views. It features a component lifecycle manager that triggers logic and state updates based on when UI components mount or unmount. The project covers dependency injection for reducing co

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

Redux is a JavaScript state management library that serves as a centralized state container for application data. It operates as a predictable state machine, maintaining the entire application state in a single immutable object tree to ensure a consistent source of truth. The library enforces a unidirectional data flow architecture where the state is read-only and can only be modified by dispatching action objects. State transitions are calculated by applying pure reducer functions to the current state and a specific action, ensuring that data updates are deterministic and trackable. The sys

Om is a frontend state management library and reactive user interface framework that integrates ClojureScript functional programming with the React virtual DOM rendering engine. It provides a bridge to build responsive web interfaces where visual elements automatically update when underlying application data changes. The project centers on a normalized state store that flattens complex data structures into a relational format. This data is accessed through a reader-based querying system, which decouples the user interface from the state by allowing components to declare specific data requirem

Akita is a JavaScript state management library that provides a system for managing application data and user interface state. It utilizes an observable data store and immutable state containers to synchronize data across interfaces, employing an entity state manager to handle flat collections of objects with unique identifiers. The project distinguishes itself through a comprehensive history management system that supports both global application-wide state reversal and granular, per-entity undo and redo functionality. It also includes a client-side data cache with time-to-live settings to pr

Immer is an immutable state management library for JavaScript that enables the creation of new versions of state trees. It functions as a state container that uses a proxy-based handler to ensure data immutability. The library utilizes a copy-on-write mechanism and a draft-based mutation model. This allows users to write mutating code on a temporary proxy, which the system then uses to produce a new immutable result while keeping the original state unchanged. The project covers immutable state management and complex object cloning to facilitate predictable state transitions. These capabiliti

This project is a Redux state logger and console debugging tool. It functions as middleware for the Redux dispatch pipeline, acting as a state transition tracker that records actions and state changes directly to the browser console. The tool allows for the interception of actions to log timing, payloads, and state transitions. It provides capabilities to filter specific actions using predicate functions to reduce noise and transform complex state or immutable data into readable formats for easier inspection. The utility includes options for customizing console output through timestamps, col

This repository is a collection of learning resources, instructional materials, and practical reference implementations for the React library. It provides code snapshots, application boilerplates, and a repository of examples designed to support a structured curriculum for building React applications. The project offers specific implementation guides and samples for managing application state, mapping routes with shared layouts, and creating validated form systems. It includes versioned code snapshots, completed exercise references, and presentation materials to help users validate their prog

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

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

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

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

Redux-thunk is a middleware for Redux that enables action creators to return functions instead of plain objects. It serves as an asynchronous state management tool and functional action dispatcher that coordinates complex workflows and delays state updates until asynchronous tasks are complete. This middleware grants action creators access to the store state and dispatch methods, allowing for the execution of conditional logic and the coordination of multiple asynchronous operations. It enables the injection of custom dependencies and service layers to decouple business logic from the core st

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

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

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

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

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 library of reusable React hooks designed to simplify browser API integration, state management, and component lifecycle tracking. It provides a declarative interface for managing complex browser interactions, allowing developers to encapsulate imperative logic into modular, composable functions that integrate directly with the component lifecycle. The library distinguishes itself by offering specialized utilities for asynchronous data orchestration, including built-in caching, retry logic, and loading state management. It also features advanced performance opti

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

Redux-form is a form state management library that synchronizes user input and form metadata with a global Redux store. It acts as a bridge between form input fields and the Redux ecosystem, ensuring predictable state transitions through a centralized state manager. The library utilizes Higher Order Components to connect React applications to the Redux store. This approach offloads state management from local components to a global store, facilitating the orchestration of complex forms with numerous fields. The system maintains consistency through a unidirectional data flow, integrating form

Recoil is an atomic state management framework and library for React. It functions as a state container that breaks application data into independent units called atoms to minimize unnecessary component re-renders. The system integrates with React hooks to provide a reactive state store. It utilizes a graph-based approach to data flow, employing a dependency graph to track relationships between state units and propagate updates automatically. The library coordinates global state across complex component trees, enabling independent components to communicate and share data without manual prop