Open-source alternatives to Usehooks

usehooks-ts is a comprehensive collection of reusable TypeScript-based hooks designed for managing state, DOM events, and browser API interactions within React applications. It provides a typed library of functions to handle common frontend patterns and side effects. The project distinguishes itself by offering specialized hooks for browser integration, including tools for interacting with the system clipboard, managing local and session storage persistence, and loading external scripts. It also includes utilities for responsive UI development, such as tracking media queries, window dimension

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 a collection of reusable React hooks designed to wrap browser APIs, manage state persistence, and handle DOM observation. It provides a consistent interface for integrating native browser capabilities directly into the React component lifecycle. The library includes specialized toolkits for monitoring the browser environment, such as window resizing, network connectivity, and viewport visibility. It also provides mechanisms for managing execution timing through debouncing, throttling, and the control of timeouts and intervals. Additional capabilities cover state management wi

This library provides a collection of reusable hooks designed to manage state, side effects, and browser interactions within React applications. It functions as a toolkit for handling asynchronous data fetching and complex component logic, offering a set of type-safe utilities that reduce boilerplate code and improve maintainability. The library distinguishes itself through its focus on isomorphic lifecycle synchronization, ensuring consistent behavior across client and server environments to prevent hydration mismatches. It employs ref-based closure stabilization to ensure that asynchronous

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 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 technical study resource and interview preparation guide focused on the React library. It provides a comprehensive frontend interview question bank and concept references designed to help developers master core library primitives and prepare for professional job interviews. The resource covers detailed explanations of React's technical architecture, including state management patterns, performance optimization strategies, and component design. It serves as a knowledge assessment tool for developers to test their understanding of modern frontend engineering through a structur

This project is a collection of official plugin packages and a native integration library designed to provide a consistent interface for accessing hardware and software functionality across different mobile and desktop platforms. It serves as a native platform bridge, enabling cross-platform applications to invoke native code and manage operating system dependencies. The project utilizes a federated plugin architecture, splitting plugins into common interfaces and separate platform implementations to allow for independent development and extension. It further supports native integration throu

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

Alova is a frontend data fetching library and HTTP request toolkit designed to manage remote data states and asynchronous communication in web applications. It functions as a request state management system that automates data retrieval, response caching, and synchronization between backend services and the user interface. The library distinguishes itself through a modular architecture that decouples network transport layers from request logic, allowing for consistent behavior across different environments. It utilizes a plugin-driven middleware system to extend core operations, enabling the

This project is a curated library of reusable logic designed to simplify state management and component behavior in web applications. It functions as a frontend development toolkit that provides a collection of community-driven hooks to handle common tasks within the component lifecycle. The library distinguishes itself by offering a centralized repository of shared solutions for managing complex data and interface interactions. By providing pre-built abstractions for browser interfaces, network data requests, and user interface components, it allows developers to replace repetitive boilerpla

This project is a comprehensive collection of reusable code snippets, custom hooks, and implementation patterns for building user interfaces with React. It serves as a library of short examples designed to solve common development tasks, ranging from state management to DOM integration. The collection provides a wide array of specialized utilities for interacting with browser APIs, including window dimension tracking, media query evaluation, and online status monitoring. It also includes practical guides and snippets for performance optimization, such as memoization, lazy loading, and state c

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

TanStack Router is a type-safe routing library for web applications that provides full type safety for paths, search parameters, and data loaders across the entire application stack. It functions as a comprehensive framework for server-side rendering, enabling the generation of complete HTML pages to improve initial load performance and search engine optimization. By integrating declarative data fetching, the library manages asynchronous information at the route level, supporting preloading, caching, and parallel request execution to ensure data is ready before components render. The project

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

Got is a promise-based HTTP request library for Node.js that supports HTTP/2 and streaming. It provides a system for making network requests with a focus on asynchronous control flow and type-safe API client development. The library is distinguished by its middleware-based request lifecycle, which uses interceptors and plugins to modify request options and response data. It includes a configurable automatic retry mechanism with backoff strategies, a built-in HTTP response cache, and a cookie-jar system for maintaining persistent sessions. Broad capabilities cover data handling through duplex

This project is a comprehensive Java backend engineering guide and technical reference focused on high-concurrency design, distributed systems, and microservices architecture. It provides detailed strategies for decomposing monolithic applications, managing service discovery, and implementing the architectural patterns required for scalable backend environments. The repository distinguishes itself through an extensive collection of big data algorithmic references and database scaling strategies. It covers memory-efficient techniques for analyzing massive datasets, such as Top-K element extrac

30-seconds-of-code is a comprehensive knowledge base and programming snippet library designed to support software engineering education and professional development. It provides a curated collection of reusable code units and technical guides that help developers master core language mechanics, design patterns, and architectural philosophies. The project distinguishes itself by offering a wide-ranging library of algorithmic solutions and web development patterns that are organized into modular, independently testable units. It emphasizes functional programming paradigms and declarative logic,

Firefox is a cross-platform web browser engine designed to render web content, execute JavaScript, and manage secure browsing sessions. It utilizes a multi-process isolation architecture that distributes browser tasks across independent operating system processes to ensure stability and prevent site-specific failures from impacting the entire application. The engine incorporates a sandboxed execution environment to restrict web content and untrusted scripts to isolated memory compartments, enforcing security policies that prevent unauthorized access to system resources. The project distinguis

TanStack Table is a headless, framework-agnostic engine designed for building complex data grids and managing tabular state. By decoupling data processing logic from the visual rendering layer, it allows developers to implement custom user interfaces while offloading sophisticated operations like sorting, filtering, grouping, and pagination to a unified, performant core. The library distinguishes itself through its commitment to type safety and environment flexibility. It leverages strict type definitions to ensure data integrity across the entire application and utilizes an adapter pattern t

This project is a comprehensive instructional resource and tutorial guide for learning React and the broader frontend engineering ecosystem. It serves as a structured course covering the fundamentals of building user interfaces through component-based architecture. The project provides specialized guides on coordinating application data via Redux state management, integrating and mutating data using GraphQL and Relay, and building native mobile applications using a single codebase. It also includes a dedicated tutorial for verifying component behavior through unit testing, shallow rendering,

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

This project is a comprehensive framework for iOS application development, centered on building mobile applications that feature custom user interface components, asynchronous task management, and local data persistence. It serves as a technical knowledge base for software engineering, providing tools to organize and publish architectural analyses and notes in Markdown format. The framework distinguishes itself through a robust document-based storage layer that utilizes BSON-formatted records to perform CRUD operations within a NoSQL document store. It provides extensive system integration ca

This project is a JavaScript educational resource and frontend web development course. It provides a collection of starter files and final projects designed to teach the JavaScript programming language through practical application. The material functions as a project portfolio and implementation guide, demonstrating how to build interactive user interfaces using the document object model. It focuses on event handling, object oriented programming, and the integration of native browser features. The course covers a range of capability areas, including asynchronous data fetching, client-side a

Didact is a virtual DOM UI framework and a technical implementation guide for building component-based libraries from scratch. It functions as a concurrent rendering engine that divides interface updates into small units of work to maintain main-thread responsiveness. The project features a fiber-based renderer and a hook-based state manager that utilizes linked-list storage to preserve data across render cycles. It employs a double-buffered render tree to calculate updates before committing them to the user interface. The framework covers recursive DOM mounting to transform virtual elements

This project is a curated collection of technical interview questions and detailed answers designed for professional software engineering roles. It serves as an Angular framework study resource and interview guide for developers preparing for frontend engineering assessments. The resource covers core architectural patterns including component-based view architecture, hierarchical dependency injection, and declarative template binding. It also addresses implementation details regarding observable-driven data streams and the use of directives for DOM manipulation. Additional content focuses on