Open-source alternatives to Reselect

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

redux-form is a library for managing HTML form state and validation within a Redux store using React components. It functions as a state manager that synchronizes input values and interaction metadata to maintain a single source of truth in a global state container. The project provides mechanisms for orchestrating dynamic arrays of input fields that can be added, removed, or reordered in real time. It also includes a system for splitting complex data entry into a sequence of pages to create multi-step form wizards. Additional capabilities cover client-side data validation through synchronou

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 collection of frontend development best practices and standards. It provides guides for writing semantic HTML, efficient CSS, and functional JavaScript to improve overall web performance and accessibility. The repository establishes frameworks for modern CSS architecture, focusing on specificity management and the use of Flexbox and Grid for predictable layouts. It outlines patterns for functional JavaScript programming, emphasizing the use of pure functions and composition to reduce execution time and dependency bloat. The guidelines cover several core capabi

This is the comprehensive documentation website for the Vue 2 progressive JavaScript framework. It serves as a technical reference and development guide for building reactive user interfaces and single-page applications. The site provides a detailed JavaScript API reference and a web component directory. It covers the implementation of component-based architectures, reactive state management, and the use of a virtual DOM to synchronize application state with the browser. The documentation details capabilities including client-side routing, declarative DOM manipulation, and frontend build opt

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

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

This project is a curated library of algorithm implementations and solved programming problems. It serves as a reference repository for competitive programming and data structure implementations, providing optimized solutions for a wide range of coding challenges. The collection organizes code examples by algorithmic technique, specifically focusing on the implementation of trees, graphs, and heaps to optimize time and space complexity. It provides language-specific solutions used for high-performance coding tasks. The repository covers a broad set of capabilities, including graph traversals

Just is a collection of JavaScript utility libraries designed for data manipulation, functional programming, performance optimization, statistical analysis, and string processing. It provides a set of tools for deep cloning, filtering, and transforming complex objects and arrays. The project is structured as a series of zero-dependency modules, allowing utilities to be used independently to minimize bundle size. It implements functional programming patterns including currying, piping, and partial application, and provides execution control through memoization, debouncing, and throttling. The

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

This project is a data structures and algorithms library providing a collection of fifty standard code implementations for managing data and solving common computational problems. It serves as an algorithm implementation reference and study resource for educational use. The codebase covers graph theory implementations for modeling networks and performing searches, as well as string pattern matching libraries for the retrieval of character sequences. It includes a collection of hierarchical data structures, such as binary search trees and priority heaps, and provides optimized solutions for dy

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

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

Dva is a state management library and client-side application framework designed for building user interfaces with React and Redux. It functions as an asynchronous logic orchestrator and a single page application router, organizing application data through a structured data flow of reducers, effects, and subscriptions. The framework distinguishes itself through the use of generator functions to manage asynchronous workflows and sequential side effects, keeping these operations separate from synchronous state updates. It implements namespace-based model organization to group business logic and

Redux Toolkit is a state management toolkit and store configurator designed to simplify the development of Redux applications by reducing boilerplate code. It functions as an immutable state manager and a centralized store configuration system that provides a streamlined workflow for managing global application state. The project distinguishes itself through an automated async action orchestrator that manages the lifecycle of promises by automatically dispatching pending, fulfilled, and rejected actions. It also acts as a normalized state organizer, providing tools to structure complex relati

This project is a comprehensive, community-maintained knowledge base and toolkit designed for competitive programming. It serves as a centralized repository for algorithmic theory, data structures, and mathematical techniques, providing a structured reference for informatics and collegiate programming competitions. The project distinguishes itself by integrating educational content with a robust suite of automation utilities. It provides a complete workflow for competitive programming, including tools for automated test case generation, solution verification, and direct interaction with onlin

This project is a reactive state management library designed for Angular applications. It provides a centralized store that maintains a single immutable source of truth, ensuring that all application data transitions follow a predictable, unidirectional flow. The library implements the Redux pattern, utilizing discrete actions and pure functions to trigger state updates. It leverages observable streams to propagate these changes, allowing user interface components to bind reactively to specific slices of data. By isolating asynchronous operations and external interactions into independent act

This project provides a modular Redux architecture and a corresponding boilerplate generator. It implements a structural pattern for Redux state management that bundles action types, action creators, and reducers into self-contained modules. The architecture focuses on state logic colocation to prevent fragmented files and simplify the management of complex application states. A command-line tool is included to scaffold the file structure and initial code required for these modular state units. The system covers modular frontend architecture and state partitioning, utilizing reducer composit

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 is an education learning management system designed to track student progress and coordinate technical training paths within a software engineering curriculum. It is implemented as a React single page application that serves as a client for synchronizing student data and educational content. The application utilizes Redux for centralized state management to synchronize user progress across learning modules and integrates with a backend server via a REST API. The system covers student learning management and education workflow coordination, specifically focusing on curriculum pro

This project is a collection of architectural guidelines and design patterns for building applications with the React library. It provides a framework for organizing frontend architecture, component design standards, and state management strategies to reduce technical debt and complexity. The guide emphasizes a modular approach to component design, focusing on the separation of business logic from the user interface and the use of primitive props to ensure single responsibility. It advocates for a testing philosophy centered on user behavior and integration outcomes rather than internal imple

MobX is a reactive state management library and fine-grained reactivity engine. It provides an observable data store that automatically triggers updates in the user interface when data structures change, functioning as a transparent functional reactive store to maintain a consistent source of truth. The system utilizes a dependency-graph mapping and proxy-based object observation to track data dependencies. This ensures that only the specific components dependent on changed data are updated, which reduces unnecessary re-renders and optimizes frontend performance. The library supports decoupl

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

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

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

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

redux-actions is a toolkit for producing standardized action objects, mapping reducers to handlers, and orchestrating state management logic. It serves as an action creator library and reducer mapping tool designed to ensure consistent action structures across a system. The project implements the Flux Standard Action specification, generating objects with consistent type, payload, and error properties. It provides utilities to bundle related action creators into organized objects and wraps functions to automatically inject constant action types into the resulting objects. The library simplif