# reactjs/react.dev

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/reactjs-react-dev).**

11,681 stars · 7,863 forks · TypeScript · cc-by-4.0

## Links

- GitHub: https://github.com/reactjs/react.dev
- Homepage: https://react.dev/
- awesome-repositories: https://awesome-repositories.com/repository/reactjs-react-dev.md

## Topics

`documentation` `javascript` `react` `website`

## Description

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 incremental units, prioritizing urgent user interactions to maintain responsiveness. It provides a clear boundary between server-side data fetching and client-side interactivity, allowing developers to partition code execution environments effectively. This architecture is supported by hook-based state management, which encapsulates logic and lifecycle behaviors into reusable functions, and hydration-based rendering, which transforms static server-generated markup into fully interactive experiences.

Beyond its core rendering capabilities, the project offers a comprehensive suite of tools for managing application state, handling asynchronous data, and coordinating complex form interactions. It includes built-in support for error boundaries, context-based dependency injection, and performance optimizations like automatic memoization and non-blocking state transitions. These features enable the construction of scalable, full-stack web applications and cross-platform interfaces that share logic across different environments.

The repository serves as the official source for the library, providing extensive documentation and guidance on development standards, component architecture, and integration strategies for both new and existing projects.

## Tags

### User Interface & Experience

- [Declarative UI Toolkits](https://awesome-repositories.com/f/user-interface-experience/declarative-ui-toolkits.md) — Provides a declarative programming model that automatically synchronizes the user interface with application state through a virtual document representation.
- [Component Data Passing](https://awesome-repositories.com/f/user-interface-experience/component-architectures/component-communication-patterns/component-data-passing.md) — Provides mechanisms for passing data from parent components to child components using properties to configure behavior. ([source](https://react.dev/learn/passing-data-deeply-with-context.md))
- [Component-Based UI Frameworks](https://awesome-repositories.com/f/user-interface-experience/component-based-ui-frameworks.md) — Enables the construction of complex web applications by composing modular, reusable components and managing state across the component tree.
- [JSX Syntax Support](https://awesome-repositories.com/f/user-interface-experience/component-utilities/ui-frameworks/rendering-models/jsx-syntax-extensions/jsx-syntax-support.md) — Enables embedding HTML-like markup directly within JavaScript logic to define user interface components. ([source](https://react.dev/learn/writing-markup-with-jsx.md))
- [Cross-Platform UI Frameworks](https://awesome-repositories.com/f/user-interface-experience/cross-platform-ui-frameworks.md) — Provides a framework for building consistent user interfaces that run across web, mobile, and native environments.
- [Reusable UI Components](https://awesome-repositories.com/f/user-interface-experience/reusable-ui-components.md) — Provides a modular component-based architecture for building interactive user interfaces. ([source](https://react.dev/learn/tutorial-tic-tac-toe.md))
- [UI Component Libraries](https://awesome-repositories.com/f/user-interface-experience/ui-component-libraries.md) — Ships a library for building interactive user interfaces from reusable, stateful components using a declarative syntax.
- [Custom Hooks](https://awesome-repositories.com/f/user-interface-experience/presentation-frameworks/lifecycle-state-management/component-lifecycle-management/component-logic-patterns/custom-hooks.md) — Encapsulates stateful logic into reusable custom functions shared across components. ([source](https://react.dev/reference/react/hooks.md))
- [State Management](https://awesome-repositories.com/f/user-interface-experience/state-management.md) — Synchronizes user interface components with application data by automatically updating the view when state changes.
- [Form Input Components](https://awesome-repositories.com/f/user-interface-experience/ui-components/form-input-components.md) — Synchronizes input element values with component state to ensure the user interface reflects the current data model in real time. ([source](https://react.dev/reference/react-dom/components.md))
- [User Interface Frameworks](https://awesome-repositories.com/f/user-interface-experience/user-interface-frameworks.md) — Enables the construction of interactive views through declarative component composition. ([source](https://react.dev/learn.md))
- [Conditional Rendering](https://awesome-repositories.com/f/user-interface-experience/conditional-rendering.md) — Provides logic for displaying UI elements based on boolean conditions or state changes within component functions. ([source](https://react.dev/learn/conditional-rendering.md))
- [Cross-Platform Development](https://awesome-repositories.com/f/user-interface-experience/cross-platform-development.md) — Enables the creation of interactive interfaces that run on web and mobile platforms using a unified codebase.
- [Dynamic List Rendering](https://awesome-repositories.com/f/user-interface-experience/dynamic-list-rendering.md) — Transforms arrays of data into collections of user interface components by mapping over items and returning corresponding elements. ([source](https://react.dev/learn/tutorial-tic-tac-toe.md))
- [Form Handling](https://awesome-repositories.com/f/user-interface-experience/form-and-input-management/form-handling.md) — Manages form state, submission lifecycles, and data synchronization with server-side functions. ([source](https://react.dev/reference/react/useActionState.md))
- [Interaction Handlers](https://awesome-repositories.com/f/user-interface-experience/form-and-input-management/interaction-and-event-handling/interaction-logic-hooks/interaction-handlers.md) — Provides mechanisms for executing custom logic or callbacks in response to specific user interactions with interface elements. ([source](https://react.dev/learn/adding-interactivity.md))
- [Form State Management](https://awesome-repositories.com/f/user-interface-experience/form-state-management.md) — Provides utilities for binding complex form inputs to data models and synchronizing state across multiple components. ([source](https://react.dev/reference/react-dom/hooks.md))
- [Component-Based Rendering](https://awesome-repositories.com/f/user-interface-experience/node-based-ui-components/component-based-ui-integrations/component-based-rendering.md) — Displays component trees into managed roots and updates content while preserving internal state. ([source](https://react.dev/reference/react-dom/client/createRoot.md))
- [Component Lifecycle Management](https://awesome-repositories.com/f/user-interface-experience/presentation-frameworks/lifecycle-state-management/component-lifecycle-management.md) — Manages the creation, update, and destruction of components throughout their lifecycle. ([source](https://react.dev/reference/react-dom/client/hydrateRoot.md))
- [Component Lifecycle Hooks](https://awesome-repositories.com/f/user-interface-experience/presentation-frameworks/lifecycle-state-management/component-lifecycle-management/component-lifecycle-hooks.md) — Executes custom logic at specific stages of a component's existence, such as after mounting or before unmounting. ([source](https://react.dev/reference/react/Component.md))
- [Component Logic Patterns](https://awesome-repositories.com/f/user-interface-experience/presentation-frameworks/lifecycle-state-management/component-lifecycle-management/component-logic-patterns.md) — Encapsulates stateful logic and lifecycle behaviors into reusable functions to share behavior across multiple components. ([source](https://react.dev/learn/reusing-logic-with-custom-hooks.md))
- [UI State Management](https://awesome-repositories.com/f/user-interface-experience/ui-architecture/immediate-mode-ui-development/ui-state-management.md) — Tracks and updates the visual state of components in response to user input. ([source](https://react.dev/learn/managing-state.md))
- [Suspenseful Data Loading](https://awesome-repositories.com/f/user-interface-experience/asynchronous-data-fetching/suspenseful-data-loading.md) — Supports asynchronous component functions that suspend rendering until data is ready. ([source](https://react.dev/reference/rsc/server-components.md))
- [Context Providers](https://awesome-repositories.com/f/user-interface-experience/component-architectures/component-communication-patterns/component-data-passing/context-providers.md) — Subscribes to shared data from distant parent components without manual property drilling. ([source](https://react.dev/reference/react/hooks.md))
- [HTML Element Wrappers](https://awesome-repositories.com/f/user-interface-experience/component-architectures/html-element-wrappers.md) — Maps standard browser HTML and SVG elements to components with enhanced property support for declarative markup. ([source](https://react.dev/reference/react-dom/components.md))
- [Component Prop Validation](https://awesome-repositories.com/f/user-interface-experience/component-utilities/ui-frameworks/component-apis/component-prop-validation.md) — Enables static analysis and correctness checking for component inputs through property annotations. ([source](https://react.dev/learn/typescript.md))
- [Component Structure Validators](https://awesome-repositories.com/f/user-interface-experience/component-utilities/ui-frameworks/component-libraries/react-components/component-structure-validators.md) — Verifies that components and hooks are defined at the module level to prevent unnecessary re-creation. ([source](https://react.dev/reference/eslint-plugin-react-hooks/lints/component-hook-factories.md))
- [Children Utilities](https://awesome-repositories.com/f/user-interface-experience/component-utilities/ui-frameworks/composition-slots/children-utilities.md) — Provides utilities for iterating, counting, and transforming opaque component children structures during rendering. ([source](https://react.dev/reference/react/Children.md))
- [Context-Based Dependency Injection](https://awesome-repositories.com/f/user-interface-experience/context-based-dependency-injection.md) — Broadcasts shared data through the component tree to avoid manual property drilling and provide global access to application state.
- [Template Fragment Grouping](https://awesome-repositories.com/f/user-interface-experience/element-groupings/template-fragment-grouping.md) — Provides mechanisms for grouping multiple elements under a single container to avoid unnecessary DOM wrappers. ([source](https://react.dev/learn/rendering-lists.md))
- [Form Submission Management](https://awesome-repositories.com/f/user-interface-experience/form-submission-management.md) — Handles form submission lifecycles, allowing custom logic execution and automatic field resetting. ([source](https://react.dev/reference/react-dom/components/form.md))
- [Fragment Components](https://awesome-repositories.com/f/user-interface-experience/fragment-components.md) — Groups multiple elements into a single unit without adding unnecessary wrapper nodes to the document structure. ([source](https://react.dev/learn/writing-markup-with-jsx.md))
- [Modular UI Components](https://awesome-repositories.com/f/user-interface-experience/modular-ui-components.md) — Organizes user interface code into separate files by exporting components and importing them into other parts of the application. ([source](https://react.dev/learn/importing-and-exporting-components.md))
- [Cross-Platform Rendering](https://awesome-repositories.com/f/user-interface-experience/native-ui-component-libraries/web-based-native-ui/cross-platform-rendering.md) — Enables the construction of cross-platform interfaces that share logic across different environments. ([source](https://react.dev/learn/creating-a-react-app.md))
- [Side Effect Cleanup Utilities](https://awesome-repositories.com/f/user-interface-experience/ui-architecture/reactivity-systems/side-effect-cleanup-utilities.md) — Provides mechanisms to cancel or reset operations when components unmount or effects re-run to prevent memory leaks. ([source](https://react.dev/learn/synchronizing-with-effects.md))
- [Loading Placeholders](https://awesome-repositories.com/f/user-interface-experience/ui-components/feedback-overlay-components/loading-indicators/loading-placeholders.md) — Provides visual placeholder components to indicate loading states while child elements or data are being fetched. ([source](https://react.dev/reference/react/components.md))
- [Asynchronous Data Fetching](https://awesome-repositories.com/f/user-interface-experience/asynchronous-data-fetching.md) — Fetches and manages remote data within components while handling loading states and race conditions.
- [Portal Rendering](https://awesome-repositories.com/f/user-interface-experience/component-hierarchies/portal-rendering.md) — Projects component children into different DOM nodes while preserving the original component's context and state. ([source](https://react.dev/reference/react-dom/createPortal.md))
- [Component References](https://awesome-repositories.com/f/user-interface-experience/component-references.md) — Provides mechanisms for accessing underlying DOM nodes or persisting values across renders using stable references. ([source](https://react.dev/reference/react/createRef.md))
- [Dependency Validation Rules](https://awesome-repositories.com/f/user-interface-experience/component-utilities/ui-frameworks/rendering-models/component-architecture/hooks/dependency-validation-rules.md) — Ensures dependency arrays include all reactive values to prevent stale closures. ([source](https://react.dev/reference/eslint-plugin-react-hooks/lints/exhaustive-deps.md))
- [Effect Synchronization](https://awesome-repositories.com/f/user-interface-experience/component-utilities/ui-frameworks/rendering-models/component-architecture/hooks/effect-synchronization.md) — Synchronizes component state with external systems while decoupling logic from side effects. ([source](https://react.dev/reference/react/useEffectEvent.md))
- [Element Groupings](https://awesome-repositories.com/f/user-interface-experience/element-groupings.md) — Provides containers that combine multiple UI elements into a single, visually unified component. ([source](https://react.dev/reference/react/Fragment.md))
- [Event Propagation Systems](https://awesome-repositories.com/f/user-interface-experience/event-propagation-systems.md) — Controls event bubbling and capturing phases within the component tree to manage user interactions. ([source](https://react.dev/learn/responding-to-events.md))
- [Submission Lifecycle Hooks](https://awesome-repositories.com/f/user-interface-experience/form-submission-management/submission-lifecycle-hooks.md) — Provides mechanisms for intercepting form submission events to execute custom logic or monitor pending states. ([source](https://react.dev/reference/react-dom/hooks.md))
- [Update Schedulers](https://awesome-repositories.com/f/user-interface-experience/main-thread-dispatchers/update-schedulers.md) — Prioritizes urgent interactions by deferring non-critical re-renders. ([source](https://react.dev/reference/react/useDeferredValue.md))
- [Animation Transition Components](https://awesome-repositories.com/f/user-interface-experience/ui-components/animation-transition-components.md) — Wraps component trees to trigger visual animations when elements enter, exit, or update. ([source](https://react.dev/reference/react/ViewTransition.md))
- [Form Handling Components](https://awesome-repositories.com/f/user-interface-experience/ui-components/form-input-components/form-handling-components.md) — Provides components that extend standard form functionality to automate data submission and manage form-related states. ([source](https://react.dev/reference/react-dom/hooks/useFormStatus.md))
- [Update Batching](https://awesome-repositories.com/f/user-interface-experience/update-batching.md) — Groups multiple state updates into single render cycles to improve performance. ([source](https://react.dev/learn/queueing-a-series-of-state-updates.md))
- [Data Isolation Strategies](https://awesome-repositories.com/f/user-interface-experience/component-architectures/component-communication-patterns/component-data-passing/data-isolation-strategies.md) — Ensures each component instance maintains independent private memory. ([source](https://react.dev/learn/state-a-components-memory.md))
- [Exposed Component APIs](https://awesome-repositories.com/f/user-interface-experience/component-utilities/ui-frameworks/component-apis/interface-configuration-definitions/component-interfaces/exposed-component-apis.md) — Exposes internal component methods to parent components via references for direct interaction. ([source](https://react.dev/reference/react/useImperativeHandle.md))
- [Component Compilers](https://awesome-repositories.com/f/user-interface-experience/component-utilities/ui-frameworks/component-libraries/react-components/component-compilers.md) — Optimizes rendering performance by controlling the inclusion of functions in automatic memoization. ([source](https://react.dev/reference/react-compiler/directives.md))
- [Property Passing](https://awesome-repositories.com/f/user-interface-experience/component-utilities/ui-frameworks/rendering-models/component-architecture/property-passing.md) — Enables passing complex data structures and configuration objects into components via read-only input properties. ([source](https://react.dev/learn/javascript-in-jsx-with-curly-braces.md))
- [Class Components](https://awesome-repositories.com/f/user-interface-experience/component-utilities/ui-frameworks/rendering-models/composition-rendering-patterns/component-patterns/class-components.md) — Supports class-based component definitions for managing state and lifecycle methods. ([source](https://react.dev/reference/react/Component.md))
- [Pure Rendering Enforcers](https://awesome-repositories.com/f/user-interface-experience/component-utilities/ui-frameworks/rendering-models/composition-rendering-patterns/component-patterns/pure-components/pure-rendering-enforcers.md) — Enforces component purity by preventing side effects and global variable mutation during the rendering process. ([source](https://react.dev/learn/describing-the-ui.md))
- [List Filtering Utilities](https://awesome-repositories.com/f/user-interface-experience/data-display-components/list-components/list-filtering-utilities.md) — Provides logic for displaying subsets of data collections based on dynamic criteria without mutating the source. ([source](https://react.dev/learn/rendering-lists.md))
- [Escape Hatches](https://awesome-repositories.com/f/user-interface-experience/escape-hatches.md) — Holds non-rendering data or interacts with browser APIs by providing an escape hatch from the standard rendering lifecycle. ([source](https://react.dev/reference/react/hooks.md))
- [Form Action Handlers](https://awesome-repositories.com/f/user-interface-experience/form-action-handlers.md) — Trigger distinct behaviors or specific functions based on which button within a form is activated by the user. ([source](https://react.dev/reference/react-dom/components/form.md))
- [Cross-Browser Event Managers](https://awesome-repositories.com/f/user-interface-experience/form-and-input-management/interaction-and-event-handling/event-handling-architectures/event-handling-systems/cross-browser-event-managers.md) — Registers event listeners for browser interactions using normalized event objects that ensure consistent behavior across different browsers. ([source](https://react.dev/learn.md))
- [Imperative Handle Customizations](https://awesome-repositories.com/f/user-interface-experience/presentation-frameworks/lifecycle-state-management/component-lifecycle-management/component-lifecycle-hooks/imperative-handle-customizations.md) — Restricts exposed component interfaces by providing custom objects of methods via ref handles. ([source](https://react.dev/reference/react/forwardRef.md))

### Software Engineering & Architecture

- [Context State Propagators](https://awesome-repositories.com/f/software-engineering-architecture/state-synchronization-patterns/context-state-propagators.md) — Shares application state across component trees using provider patterns to avoid manual property drilling. ([source](https://react.dev/learn/scaling-up-with-reducer-and-context.md))
- [Stateful Composables](https://awesome-repositories.com/f/software-engineering-architecture/architectural-design-patterns/state-management/stateful-composables.md) — Encapsulates stateful logic into reusable functions to share behavior across components. ([source](https://react.dev/learn/escape-hatches.md))
- [Coding Standards Enforcement](https://awesome-repositories.com/f/software-engineering-architecture/coding-standards-enforcement.md) — Automates the enforcement of architectural patterns and logic constraints for components and hooks. ([source](https://react.dev/reference/react.md))
- [Error Boundaries](https://awesome-repositories.com/f/software-engineering-architecture/error-boundaries.md) — Catches rendering errors in child components to display fallback user interfaces and log diagnostic information. ([source](https://react.dev/reference/react/Component.md))
- [Hook Usage Rules](https://awesome-repositories.com/f/software-engineering-architecture/hook-usage-rules.md) — Maintains consistent user interface logic by requiring hooks to be called only at the top level of functions. ([source](https://react.dev/reference/rules.md))
- [Immutable State Patterns](https://awesome-repositories.com/f/software-engineering-architecture/software-architecture/architectural-patterns/layering-presentation/application-layer-architectures/state-management-architectures/immutable-data-strategies/immutable-state-patterns.md) — Ensures predictable state management by enforcing data immutability for props and state. ([source](https://react.dev/reference/eslint-plugin-react-hooks/lints/immutability.md))
- [Immutable Update Utilities](https://awesome-repositories.com/f/software-engineering-architecture/software-architecture/architectural-patterns/layering-presentation/application-layer-architectures/state-management-architectures/immutable-data-strategies/immutable-update-utilities.md) — Replaces existing objects or arrays with new versions during state updates to ensure predictable re-renders. ([source](https://react.dev/reference/react/useState.md))
- [Immutable State Utilities](https://awesome-repositories.com/f/software-engineering-architecture/architectural-design-patterns/state-management/state-logic-and-utilities/immutable-state-utilities.md) — Modifies deeply nested properties by creating chains of shallow copies to maintain immutability. ([source](https://react.dev/learn/updating-objects-in-state.md))
- [Logic Hooks](https://awesome-repositories.com/f/software-engineering-architecture/core-business-logic/logic-hooks.md) — Encapsulates repetitive side-effect logic into reusable hooks for declarative behavior. ([source](https://react.dev/reference/react/useEffect.md))
- [Incompatible Rule Replacements](https://awesome-repositories.com/f/software-engineering-architecture/custom-analysis-rules/incompatible-rule-replacements.md) — Identifies third-party API usage that conflicts with automatic memoization to prevent interface unresponsiveness. ([source](https://react.dev/reference/eslint-plugin-react-hooks/lints/incompatible-library.md))
- [Caching and Memoization](https://awesome-repositories.com/f/software-engineering-architecture/performance-reliability/performance-optimization/caching-memoization.md) — Stores results of expensive computations and data fetches to avoid redundant processing. ([source](https://react.dev/reference/react/cache.md))
- [Memoization Hooks](https://awesome-repositories.com/f/software-engineering-architecture/performance-reliability/performance-optimization/caching-memoization/memoization-hooks.md) — Optimizes performance by caching expensive computations through memoization hooks. ([source](https://react.dev/reference/eslint-plugin-react-hooks/lints/use-memo.md))
- [Rendering Optimizations](https://awesome-repositories.com/f/software-engineering-architecture/performance-reliability/performance-optimization/frontend-rendering-loading/rendering-optimizations.md) — Controls component re-renders by comparing props and state to skip unnecessary updates. ([source](https://react.dev/reference/react/Component.md))
- [External Store Synchronization](https://awesome-repositories.com/f/software-engineering-architecture/software-architecture/architectural-patterns/layering-presentation/application-layer-architectures/state-management-architectures/external-store-synchronization.md) — Connects components to external systems by running setup and cleanup logic during the component lifecycle. ([source](https://react.dev/learn/escape-hatches.md))
- [Hydration Warning Suppressors](https://awesome-repositories.com/f/software-engineering-architecture/warning-issuance-systems/warning-suppressions/hydration-warning-suppressors.md) — Disables warnings triggered by content mismatches between server-rendered and client-rendered output. ([source](https://react.dev/reference/react-dom/components/common.md))
- [Root Container Initializers](https://awesome-repositories.com/f/software-engineering-architecture/application-lifecycle-management/app-bootstrap-and-identity/root-initialization-utilities/root-container-initializers.md) — Creates managed containers within browser DOM elements to display and update components. ([source](https://react.dev/reference/react-dom/client/createRoot.md))
- [Development Best Practices](https://awesome-repositories.com/f/software-engineering-architecture/development-best-practices.md) — Enforces coding standards and identifies common mistakes during development to ensure best practices. ([source](https://react.dev/learn/editor-setup.md))
- [Execution Priorities](https://awesome-repositories.com/f/software-engineering-architecture/plugin-execution-engines/execution-priorities.md) — Categorizes background and user-initiated work by priority level to manage rendering and task scheduling. ([source](https://react.dev/reference/dev-tools/react-performance-tracks.md))
- [Event Extraction Utilities](https://awesome-repositories.com/f/software-engineering-architecture/reactive-effects/event-extraction-utilities.md) — Isolates non-reactive logic from side effects to prevent unnecessary re-synchronization. ([source](https://react.dev/learn/separating-events-from-effects.md))
- [Utilities](https://awesome-repositories.com/f/software-engineering-architecture/rendering-diagnostics/impurity-detection/utilities.md) — Detects bugs by intentionally re-running rendering and effects to expose impurities or missing cleanup routines. ([source](https://react.dev/reference/react/StrictMode.md))

### Web Development

- [Server Components](https://awesome-repositories.com/f/web-development/rendering-templating/server-side-rendering-utilities/server-components.md) — Executes components on the server to access data without increasing client-side bundle size. ([source](https://react.dev/learn/creating-a-react-app.md))
- [Server-Side Rendering Frameworks](https://awesome-repositories.com/f/web-development/server-side-rendering-frameworks.md) — Provides a framework for server-side rendering to improve initial page load performance and search engine optimization.
- [Bundle Optimizers](https://awesome-repositories.com/f/web-development/bundle-optimizers.md) — Compiles source code and dependencies into optimized bundles for deployment using specialized build tools. ([source](https://react.dev/learn/build-a-react-app-from-scratch.md))
- [Full-Stack Web Applications](https://awesome-repositories.com/f/web-development/full-stack-web-applications.md) — Integrates server-side rendering, routing, and bundling to create complete full-stack web applications. ([source](https://react.dev/learn/creating-a-react-app.md))
- [Nested Routing](https://awesome-repositories.com/f/web-development/nested-routing.md) — Maps browser URLs to hierarchical views and manages navigation, parameters, and data prefetching. ([source](https://react.dev/learn/build-a-react-app-from-scratch.md))
- [Server-Side Rendering](https://awesome-repositories.com/f/web-development/rendering-templating/server-side-rendering.md) — Generates HTML on the server to improve initial page load performance and search engine visibility. ([source](https://react.dev/reference/react.md))
- [Asynchronous State Management](https://awesome-repositories.com/f/web-development/asynchronous-state-management.md) — Synchronizes remote server data with the user interface through automated fetching, caching, and background updates. ([source](https://react.dev/reference/react/useActionState.md))
- [Client-Side Directives](https://awesome-repositories.com/f/web-development/client-side-components/client-side-directives.md) — Provides directives to partition code execution between server and client environments. ([source](https://react.dev/reference/rsc/use-client.md))
- [Dynamic Content Insertion](https://awesome-repositories.com/f/web-development/content-insertion-utilities/dynamic-content-insertion.md) — Embeds JavaScript logic directly into markup using curly braces to display variables, expressions, and conditional content. ([source](https://react.dev/learn.md))
- [Data Fetching](https://awesome-repositories.com/f/web-development/data-fetching-caching/data-fetching.md) — Provides utilities for retrieving, caching, and managing remote data resources within components. ([source](https://react.dev/reference/react/useEffect.md))
- [Declarative UI Composition](https://awesome-repositories.com/f/web-development/declarative-ui-composition.md) — Constructs user interfaces by nesting modular, self-contained functions that describe the desired visual state.
- [DOM Access References](https://awesome-repositories.com/f/web-development/dom-access-references.md) — Enables direct imperative interaction with underlying browser DOM nodes. ([source](https://react.dev/learn/manipulating-the-dom-with-refs.md))
- [Keyed List Reconciliation](https://awesome-repositories.com/f/web-development/dom-patching/list-patching/keyed-list-reconciliation.md) — Uses unique item keys to perform efficient list mutations and track individual items during state changes. ([source](https://react.dev/learn/rendering-lists.md))
- [Environment Partitioning](https://awesome-repositories.com/f/web-development/environment-partitioning.md) — Marks specific modules to execute exclusively on the client or the server to manage boundary transitions between execution environments. ([source](https://react.dev/reference/rsc/directives.md))
- [Expression Embeddings](https://awesome-repositories.com/f/web-development/expression-embeddings.md) — Supports injecting dynamic values and function results into user interface templates using curly braces. ([source](https://react.dev/learn/javascript-in-jsx-with-curly-braces.md))
- [Component State Management](https://awesome-repositories.com/f/web-development/frontend-development-tools/state-data-management/component-lifecycle-utilities/component-state-management.md) — Analyzes source code to identify violations of component patterns, hook usage, and state management rules. ([source](https://react.dev/reference/eslint-plugin-react-hooks.md))
- [HTML Hydration](https://awesome-repositories.com/f/web-development/html-hydration.md) — Attaches event listeners and state management to static server-generated HTML to transform initial markup into a fully interactive application.
- [HTML Streaming](https://awesome-repositories.com/f/web-development/html-streaming.md) — Streams server-rendered HTML to the client to enable progressive loading and hydration. ([source](https://react.dev/reference/react-dom/static.md))
- [Static HTML Generators](https://awesome-repositories.com/f/web-development/rendering-templating/server-side-rendering-utilities/static-html-generators.md) — Generates non-interactive HTML strings from component trees for static page generation. ([source](https://react.dev/reference/react-dom/server/renderToStaticMarkup.md))
- [Server-Side Rendering](https://awesome-repositories.com/f/web-development/server-side-rendering.md) — Supports server-side rendering with mechanisms to abort long-running processes and resume on the client. ([source](https://react.dev/reference/react-dom/server/renderToPipeableStream.md))
- [State Management Hooks](https://awesome-repositories.com/f/web-development/state-management-hooks.md) — Encapsulates stateful logic and lifecycle behaviors into reusable functions that maintain internal memory across component re-renders.
- [Rendering Performance Optimizations](https://awesome-repositories.com/f/web-development/browser-integration-utilities/browser-engines/rendering-performance-optimizations.md) — Caches expensive calculations and prioritizes UI updates to maintain interface responsiveness. ([source](https://react.dev/reference/react/hooks.md))
- [Context Type Definitions](https://awesome-repositories.com/f/web-development/context-type-definitions.md) — Reads shared data provided by parent components through context-based dependency injection. ([source](https://react.dev/reference/react/Component.md))
- [Data Fetching & Caching](https://awesome-repositories.com/f/web-development/data-fetching-caching.md) — Retrieves and caches remote data while managing loading and error states. ([source](https://react.dev/learn/build-a-react-app-from-scratch.md))
- [Form Mutation Handlers](https://awesome-repositories.com/f/web-development/form-mutation-handlers.md) — Supports progressive enhancement by processing server-side logic directly through standard form action attributes. ([source](https://react.dev/reference/rsc/use-server.md))
- [Component Rendering Engines](https://awesome-repositories.com/f/web-development/frontend-development-tools/frontend-frameworks/rendering-engines/component-rendering-engines.md) — Mounts and executes component-based user interface code within browser DOM environments. ([source](https://react.dev/reference/react.md))
- [Reducer State Management](https://awesome-repositories.com/f/web-development/frontend-development-tools/state-data-management/state-logic-patterns/reducer-state-management.md) — Centralizes complex state update logic into pure reducer functions for predictable state transitions. ([source](https://react.dev/learn/typescript.md))
- [Context Update Triggers](https://awesome-repositories.com/f/web-development/performance-optimizations/component-update-optimizations/manual-update-triggers/context-update-triggers.md) — Triggers re-renders in consuming components by updating state variables passed through providers. ([source](https://react.dev/reference/react/useContext.md))
- [Prerendered Content Resumption](https://awesome-repositories.com/f/web-development/prerendered-content-resumption.md) — Resumes rendering of partially generated component trees by processing postponed state and streaming the remaining output. ([source](https://react.dev/reference/react-dom/server/resume.md))
- [Streaming Rendering Utilities](https://awesome-repositories.com/f/web-development/rendering-templating/server-side-rendering-utilities/streaming-rendering-utilities.md) — Continues rendering prerendered component trees into streams to support incremental hydration. ([source](https://react.dev/reference/react-dom/static.md))
- [Virtual DOM Reconciliation](https://awesome-repositories.com/f/web-development/virtual-dom-reconciliation.md) — Calculates the minimal set of changes required to update the browser document by comparing a cached tree structure against the new state.
- [Backend-to-Frontend Bridges](https://awesome-repositories.com/f/web-development/backend-to-frontend-bridges.md) — Defines server-side functions that can be securely invoked from client components to connect frontend interfaces with backend logic. ([source](https://react.dev/reference/rsc/directives.md))
- [Resource Reading Hooks](https://awesome-repositories.com/f/web-development/data-fetching-caching/asynchronous-data-handling/resource-reading-hooks.md) — Reads values from promises or context providers within components, allowing for conditional execution and integration with suspense. ([source](https://react.dev/reference/react/use.md))
- [Form Value Initialization](https://awesome-repositories.com/f/web-development/form-value-initialization.md) — Initializes form fields with default values or checked states before user interaction begins. ([source](https://react.dev/reference/react-dom/components/input.md))
- [Partial Page Integrations](https://awesome-repositories.com/f/web-development/frontend-development-tools/frontend-frameworks/partial-page-integrations.md) — Mounts interactive user interface components into specific sections of pages built with other technologies. ([source](https://react.dev/learn/add-react-to-an-existing-project.md))
- [Component Update Optimizations](https://awesome-repositories.com/f/web-development/performance-optimizations/component-update-optimizations.md) — Automatically memoizes components and hooks to ensure only necessary parts of the interface update. ([source](https://react.dev/learn/react-compiler.md))
- [Context Memoization](https://awesome-repositories.com/f/web-development/performance-optimizations/component-update-optimizations/context-memoization.md) — Prevents unnecessary component re-renders by memoizing props and equality checks. ([source](https://react.dev/reference/react/memo.md))
- [State Lifting](https://awesome-repositories.com/f/web-development/state-lifting.md) — Moves local state to a common ancestor component to coordinate multiple child components and ensure a single source of truth. ([source](https://react.dev/learn/sharing-state-between-components.md))
- [Optimistic Updates](https://awesome-repositories.com/f/web-development/state-management/optimistic-updates.md) — Reflects expected submission outcomes in the interface immediately to improve perceived responsiveness. ([source](https://react.dev/reference/react-dom/components/form.md))
- [Static String Renderers](https://awesome-repositories.com/f/web-development/streaming-rendering/static-string-renderers.md) — Continues paused server-side renders to generate complete static HTML strings once data dependencies resolve. ([source](https://react.dev/reference/react-dom/static/resumeAndPrerenderToNodeStream.md))
- [Server Functions](https://awesome-repositories.com/f/web-development/web-infrastructure-deployment/web-infrastructure-servers/server-functions.md) — Triggers functions defined on the server directly from client components by passing references that execute remote code upon user interaction. ([source](https://react.dev/reference/rsc/server-functions.md))
- [DOM & Event Handling](https://awesome-repositories.com/f/web-development/browser-integration-utilities/dom-event-handling.md) — Applies specific event types to handlers to ensure type safety when interacting with browser events and user inputs. ([source](https://react.dev/learn/typescript.md))
- [Data Exposure Restrictions](https://awesome-repositories.com/f/web-development/client-side-components/data-exposure-restrictions.md) — Marks sensitive objects to trigger errors if accidentally passed from server-side code to client-side components. ([source](https://react.dev/reference/react/experimental_taintObjectReference.md))
- [Derived State](https://awesome-repositories.com/f/web-development/derived-state.md) — Calculates derived values during rendering to eliminate redundant state information. ([source](https://react.dev/learn/managing-state.md))
- [State Preservation Controls](https://awesome-repositories.com/f/web-development/frontend-development-tools/state-data-management/component-lifecycle-utilities/state-preservation-controls.md) — Controls state preservation by assigning unique keys to components. ([source](https://react.dev/learn/managing-state.md))
- [External Store Synchronization Hooks](https://awesome-repositories.com/f/web-development/frontend-development-tools/state-data-management/external-store-synchronization-hooks.md) — Synchronizes components with mutable external data stores using subscription and snapshot mechanisms. ([source](https://react.dev/learn/you-might-not-need-an-effect.md))
- [Deferred Loading](https://awesome-repositories.com/f/web-development/performance-optimizations/initial-page-load-optimizations/deferred-loading.md) — Delays component code loading until render time to reduce initial bundle size. ([source](https://react.dev/reference/react/apis.md))
- [Partial Hydration](https://awesome-repositories.com/f/web-development/rendering-templating/rendering-strategies/partial-hydration.md) — Enables selective hydration to allow parts of the page to become interactive independently. ([source](https://react.dev/reference/react/Activity.md))
- [Server-Side Data Loaders](https://awesome-repositories.com/f/web-development/server-side-data-loaders.md) — Runs server-side functions directly from form submissions to process data without requiring client-side scripts for basic interactions. ([source](https://react.dev/reference/react-dom/components/form.md))
- [Standard HTML Attribute Mapping](https://awesome-repositories.com/f/web-development/standard-html-attribute-mapping.md) — Maps standard HTML attributes to camelCase JavaScript properties to ensure compatibility with naming conventions. ([source](https://react.dev/learn/writing-markup-with-jsx.md))
- [State Update Loop Detectors](https://awesome-repositories.com/f/web-development/state-update-handlers/state-update-loop-detectors.md) — Identifies synchronous state updates that trigger redundant re-renders and degrade performance. ([source](https://react.dev/reference/eslint-plugin-react-hooks/lints/set-state-in-effect.md))
- [Streaming Server-Side Rendering](https://awesome-repositories.com/f/web-development/streaming-server-side-rendering.md) — Resumes rendering of partially generated component trees by applying postponed state to complete HTML output. ([source](https://react.dev/reference/react-dom/server/resumeToPipeableStream.md))
- [Custom Elements](https://awesome-repositories.com/f/web-development/web-standards/custom-elements.md) — Supports the rendering of custom HTML elements and extended built-in elements using standard web component patterns. ([source](https://react.dev/reference/react-dom/components.md))

### Data & Databases

- [Context Providers](https://awesome-repositories.com/f/data-databases/shared-memory-data-exchange/reactive-data-sharing/context-providers.md) — Provides a shared data source that child components access directly without intermediate property passing. ([source](https://react.dev/learn/managing-state.md))
- [Method Result Caches](https://awesome-repositories.com/f/data-databases/data-engineering-infrastructure/caching-performance/caching-strategies/query-result-caching/method-result-caches.md) — Caches function return values between re-renders to avoid redundant computations. ([source](https://react.dev/reference/react/useMemo.md))
- [Data Transformation](https://awesome-repositories.com/f/data-databases/data-transformation.md) — Provides utilities for mapping data collections into lists of user interface components. ([source](https://react.dev/learn/describing-the-ui.md))
- [External Data Refreshers](https://awesome-repositories.com/f/data-databases/external-data-connectors/external-data-refreshers.md) — Connects components to external data sources by providing subscription and snapshot functions for re-renders. ([source](https://react.dev/reference/react/useSyncExternalStore.md))

### Graphics & Multimedia

- [Component Rendering Lifecycles](https://awesome-repositories.com/f/graphics-multimedia/graphics-engines-rendering/rendering/systems/ui-component-lifecycle-engines/component-rendering-lifecycles.md) — Recursively executes component functions to determine UI structure and apply minimal DOM updates. ([source](https://react.dev/learn/render-and-commit.md))
- [Execution Boundary Directives](https://awesome-repositories.com/f/graphics-multimedia/graphics-engines-rendering/rendering/systems/server-side-rendering-architectures/execution-boundary-directives.md) — Separates execution environments by using directives to partition code into server-side data fetching and client-side interactive components.
- [Render Lifecycle Events](https://awesome-repositories.com/f/graphics-multimedia/graphics-engines-rendering/rendering/systems/ui-component-lifecycle-engines/component-rendering-lifecycles/render-lifecycle-events.md) — Emits events containing live details about component updates and rendering for performance visualization. ([source](https://react.dev/reference/dev-tools/react-performance-tracks.md))

### Development Tools & Productivity

- [Component Inspection Tools](https://awesome-repositories.com/f/development-tools-productivity/debugging-profiling-testing/debugging-diagnostics/debugging-inspection-tools/component-inspection-tools.md) — Provides browser-based interfaces to examine component hierarchies and modify state in real-time. ([source](https://react.dev/learn/tutorial-tic-tac-toe.md))
- [Rendering Schedulers](https://awesome-repositories.com/f/development-tools-productivity/task-schedulers/rendering-schedulers.md) — Manages rendering work in incremental units to prioritize urgent user interactions and keep the main thread responsive.
- [Bundle Size Optimization](https://awesome-repositories.com/f/development-tools-productivity/bundle-size-optimization.md) — Audits dependency trees to reduce the amount of code shipped to clients. ([source](https://react.dev/learn/understanding-your-ui-as-a-tree.md))
- [Ref Usage Rules](https://awesome-repositories.com/f/development-tools-productivity/code-quality-analysis/static-analysis-engines/static-analysis-tools/static-analysis-rules/ref-usage-rules.md) — Enforces rules that prevent unsafe access to mutable references during the component render phase. ([source](https://react.dev/reference/eslint-plugin-react-hooks/lints/refs.md))
- [Hook Execution Rules](https://awesome-repositories.com/f/development-tools-productivity/execution-hooks/hook-execution-rules.md) — Enforces consistent execution of stateful logic by restricting hook placement. ([source](https://react.dev/reference/rules/rules-of-hooks.md))
- [Native UI Integration Modules](https://awesome-repositories.com/f/development-tools-productivity/platforms-runtimes-language-services/development-platforms/mobile-wearable-ecosystems/mobile-development-frameworks/native-ui-integration-modules.md) — Allows embedding framework-driven screens into existing native mobile application codebases. ([source](https://react.dev/learn/add-react-to-an-existing-project.md))

### Programming Languages & Runtimes

- [Transition State Managers](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/concurrency-models/concurrency/transition-state-managers.md) — Marks state updates as non-blocking transitions to maintain interface responsiveness during background server operations. ([source](https://react.dev/reference/rsc/use-server.md))
- [Automatic Memoization Compilers](https://awesome-repositories.com/f/programming-languages-runtimes/compiler-interpreter-internals/compiler-toolchains/optimization-frameworks/automatic-memoization-compilers.md) — Automatically analyzes code to apply performance improvements and memoization during the build process. ([source](https://react.dev/learn/setup.md))
- [Compilation Optimization Strategies](https://awesome-repositories.com/f/programming-languages-runtimes/compiler-interpreter-internals/compiler-toolchains/optimization-frameworks/compilation-optimization-strategies.md) — Selects specific functions or components for automated optimization based on manual annotations or intelligent detection strategies. ([source](https://react.dev/reference/react-compiler/configuration.md))
- [Type Safety](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-safety.md) — Integrates static type checking to catch errors and improve maintainability during UI construction. ([source](https://react.dev/learn/setup.md))
- [Non-Blocking Suspension Points](https://awesome-repositories.com/f/programming-languages-runtimes/code-block-execution/non-blocking-suspension-points.md) — Marks state updates as non-blocking transitions to maintain interface responsiveness during background tasks. ([source](https://react.dev/reference/react/useTransition.md))
- [Build-Time Transformation Tools](https://awesome-repositories.com/f/programming-languages-runtimes/source-code-compilers/build-time-transformation-tools.md) — Analyzes and optimizes component source code during the build process to enforce best practices and improve runtime performance.

### Content Management & Publishing

- [Document Metadata Components](https://awesome-repositories.com/f/content-management-publishing/content-management-systems/content-management-platforms/enterprise-specialized-systems/document-management-systems/document-metadata-components.md) — Provides components that render elements into the document head or manage document-level metadata and resource loading. ([source](https://react.dev/reference/react-dom/components.md))

### System Administration & Monitoring

- [Error Reporting](https://awesome-repositories.com/f/system-administration-monitoring/error-reporting.md) — Hooks into error lifecycles to send diagnostic information to logging or monitoring services. ([source](https://react.dev/reference/react-dom/client/createRoot.md))

### Security & Cryptography

- [Sensitive Data Access Controls](https://awesome-repositories.com/f/security-cryptography/sensitive-data-access-controls.md) — Prevents secret values from being passed to client-side components by registering them as tainted. ([source](https://react.dev/reference/react/experimental_taintUniqueValue.md))