# day8/re-frame

**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/day8-re-frame).**

5,532 stars · 713 forks · Clojure · MIT

## Links

- GitHub: https://github.com/day8/re-frame
- Homepage: http://day8.github.io/re-frame/
- awesome-repositories: https://awesome-repositories.com/repository/day8-re-frame.md

## Topics

`clojurescript` `re-frame` `react` `reagent` `spa`

## Description

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 architecture allows developers to manage complex state transitions and external operations through pure functions, ensuring that side effects are executed by a separate interpreter rather than through imperative calls.

The system includes a comprehensive suite of capabilities for managing application architecture, including reactive data derivation, subscription-based view reconciliation, and event-driven state management. It supports advanced development workflows such as event tracing, state checkpointing, and the ability to stub side effects for isolated testing.

The project is designed for integration with React, utilizing virtual DOM reconciliation to efficiently update user interfaces. It provides a robust set of utilities for handling cross-cutting concerns, managing complex dataflow graphs, and coordinating asynchronous operations within a predictable, sequential event pipeline.

## Tags

### Software Engineering & Architecture

- [Single Page Applications](https://awesome-repositories.com/f/software-engineering-architecture/software-architecture/architectural-patterns/layering-presentation/application-layer-architectures/application-architecture-patterns/single-page-applications.md) — Provides a functional, data-oriented architecture for building scalable single-page applications. ([source](http://day8.github.io/re-frame/start-coding/))
- [Centralized State Stores](https://awesome-repositories.com/f/software-engineering-architecture/software-architecture/architectural-patterns/layering-presentation/application-layer-architectures/state-management-architectures/centralized-state-stores.md) — Maintains the entire application state in a single, globally accessible immutable database. ([source](http://day8.github.io/re-frame/application-state/))
- [Application Bootstrapping](https://awesome-repositories.com/f/software-engineering-architecture/application-bootstrapping.md) — Initializes the application by registering event handlers and effects and loading initial data into the central state store. ([source](http://day8.github.io/re-frame/Loading-Initial-Data/))
- [State Containers](https://awesome-repositories.com/f/software-engineering-architecture/architectural-design-patterns/state-management/centralized-state-containers/state-containers.md) — Maintains a single source of truth using events, handlers, and subscriptions for predictable state management.
- [Component State Bindings](https://awesome-repositories.com/f/software-engineering-architecture/architectural-design-patterns/state-management/reactive-subscription-systems/component-state-bindings.md) — Connects functional components to a centralized data store using subscriptions to read and react to specific state updates. ([source](http://day8.github.io/re-frame/reusable-components/))
- [Reactive Data Stores](https://awesome-repositories.com/f/software-engineering-architecture/architectural-design-patterns/state-management/reactive-subscription-systems/reactive-data-stores.md) — Connects user interface components to application state so that components automatically re-render whenever the underlying data changes. ([source](http://day8.github.io/re-frame/FAQs/why-didnt-my-component-update/))
- [Signals & Reactivity](https://awesome-repositories.com/f/software-engineering-architecture/architectural-design-patterns/state-management/reactive-subscription-systems/signals-reactivity.md) — Tracks state dependencies and property changes to trigger efficient updates across the application via a reactive signal graph.
- [Asynchronous Event Queueing](https://awesome-repositories.com/f/software-engineering-architecture/asynchronous-event-queueing.md) — Queues user actions as data-driven events to ensure sequential, decoupled, and unidirectional processing. ([source](http://day8.github.io/re-frame/FAQs/DoINeedReFrame/))
- [Atomic State Mutations](https://awesome-repositories.com/f/software-engineering-architecture/atomic-state-mutations.md) — Associates event identifiers with handler functions that compute new application states. ([source](http://day8.github.io/re-frame/api-re-frame.core/))
- [Data Schema Validation](https://awesome-repositories.com/f/software-engineering-architecture/data-schema-validation.md) — Enforces structural schemas on application state after event execution to detect corruption. ([source](http://day8.github.io/re-frame/Debugging/))
- [State Schema Validations](https://awesome-repositories.com/f/software-engineering-architecture/data-schema-validation/database-schema-validations/state-schema-validations.md) — Runs schema validation against the entire application state after every event handler to ensure data integrity. ([source](http://day8.github.io/re-frame/Debugging/))
- [Event-Driven Dataflow Graphs](https://awesome-repositories.com/f/software-engineering-architecture/declarative-dataflow-graphs/event-driven-dataflow-graphs.md) — Provides a reactive dataflow graph that automatically resolves inputs and computes outputs on every event. ([source](http://day8.github.io/re-frame/api-re-frame.alpha-instrumented/))
- [State Dependency Scoping](https://awesome-repositories.com/f/software-engineering-architecture/dependency-state-management/state-dependency-scoping.md) — Provides a mechanism to calculate and store derived state at static paths, decoupling data lifecycles from the component tree. ([source](http://day8.github.io/re-frame/flows-advanced-topics/))
- [Derived State Management](https://awesome-repositories.com/f/software-engineering-architecture/derived-state-management.md) — Computes materialized views of the state using a dependency graph that automatically updates derived values when inputs change.
- [Reactive Computed Values](https://awesome-repositories.com/f/software-engineering-architecture/dynamic-value-computations/reactive-computed-values.md) — Declares reactive containers that automatically re-run and update their output whenever referenced data signals change. ([source](http://day8.github.io/re-frame/flow-mechanics/))
- [Event Processing Interceptors](https://awesome-repositories.com/f/software-engineering-architecture/event-interception/global-event-interceptors/event-processing-interceptors.md) — Uses interceptors to transform event data and manage cross-cutting concerns within the event processing pipeline. ([source](http://day8.github.io/re-frame/api-re-frame.core/))
- [Event-to-State Transformations](https://awesome-repositories.com/f/software-engineering-architecture/event-to-state-transformations.md) — Provides interceptors to modify, narrow, or enrich event data and application state during the event processing lifecycle. ([source](http://day8.github.io/re-frame/api-re-frame.core-instrumented/))
- [Event Reduction Handlers](https://awesome-repositories.com/f/software-engineering-architecture/event-to-state-transformations/event-reduction-handlers.md) — Updates application state by treating event handlers as combining functions that fold incoming events into the current state. ([source](http://day8.github.io/re-frame/historical/))
- [Declarative Side Effect Handlers](https://awesome-repositories.com/f/software-engineering-architecture/functional-application-structuring/applicative-effect-handling/declarative-side-effect-handlers.md) — Computes declarative descriptions of state changes and external actions to ensure functional purity while managing system mutations. ([source](http://day8.github.io/re-frame/a-loop/))
- [Custom Effect Handlers](https://awesome-repositories.com/f/software-engineering-architecture/functional-application-structuring/applicative-effect-handling/declarative-side-effect-handlers/custom-effect-handlers.md) — Registers new effect handlers to integrate external services, such as databases, logging providers, or browser APIs, into the application flow. ([source](http://day8.github.io/re-frame/Effects/))
- [Pure Functional Cores](https://awesome-repositories.com/f/software-engineering-architecture/functional-ui-architectures/pure-functional-cores.md) — Isolates business logic into pure functions that rely solely on input arguments, decoupling code from global state. ([source](http://day8.github.io/re-frame/on-dynamics/))
- [Handler Interceptor Pipelines](https://awesome-repositories.com/f/software-engineering-architecture/global-execution-handler-registration/handler-interceptor-pipelines.md) — Processes events through a sequence of middleware functions to transform data and handle cross-cutting concerns before handlers execute.
- [Immutable State Transactions](https://awesome-repositories.com/f/software-engineering-architecture/immutable-state-transactions.md) — Maintains the entire application state in a single global immutable structure to ensure a consistent source of truth.
- [Coeffect Injection Mechanisms](https://awesome-repositories.com/f/software-engineering-architecture/integration-extensibility/dependency-injection/event-handler-injection/coeffect-injection-mechanisms.md) — Adds necessary external resources, such as timestamps or database connections, to the event processing context without compromising handler purity. ([source](http://day8.github.io/re-frame/api-re-frame.core-instrumented/))
- [Coeffect Injections](https://awesome-repositories.com/f/software-engineering-architecture/integration-extensibility/dependency-injection/event-handler-injection/coeffect-injections.md) — Injects external resources like timestamps or identifiers into event handlers via coeffects to maintain function purity. ([source](http://day8.github.io/re-frame/api-re-frame.core/))
- [Event-Driven Intent Handlers](https://awesome-repositories.com/f/software-engineering-architecture/intent-based-coordination/intent-to-action-handlers/event-driven-intent-handlers.md) — Triggers side effects like state updates or network requests through event handlers that respond to user actions. ([source](http://day8.github.io/re-frame/FAQs/LoadOnMount/))
- [Logic and Presentation Separation](https://awesome-repositories.com/f/software-engineering-architecture/logic-and-presentation-separation.md) — Separates application logic into distinct layers for data, events, queries, and views to ensure scalability. ([source](http://day8.github.io/re-frame/App-Structure/))
- [Reactive State Graphs](https://awesome-repositories.com/f/software-engineering-architecture/reactive-state-graphs.md) — Computes derived state through a dependency graph of reactive queries and subscriptions.
- [Reactive State Management](https://awesome-repositories.com/f/software-engineering-architecture/reactive-state-management.md) — Manages immutable application state through a centralized dependency graph of reactive queries and subscriptions.
- [Reactive State Subscriptions](https://awesome-repositories.com/f/software-engineering-architecture/reactive-state-subscriptions.md) — Registers query handlers that define how to fetch and compute data, returning a reactive signal that delivers values to the interface. ([source](http://day8.github.io/re-frame/api-re-frame.alpha/))
- [Schema-Based State Validation](https://awesome-repositories.com/f/software-engineering-architecture/schema-based-state-validation.md) — Runs schema-based validation against the application database after event handlers to ensure state integrity. ([source](https://day8.github.io/re-frame/Debugging/))
- [State Change Triggers](https://awesome-repositories.com/f/software-engineering-architecture/schema-based-state-validation/cross-state-validation/state-change-triggers.md) — Tracks specific database slices and triggers automatic component re-renders when underlying data changes. ([source](http://day8.github.io/re-frame/api-intro/))
- [Side Effect Handlers](https://awesome-repositories.com/f/software-engineering-architecture/side-effect-handlers.md) — Encapsulates asynchronous tasks and side effects into isolated, command-based handlers outside the primary application flow. ([source](http://day8.github.io/re-frame/api-re-frame.core-instrumented/))
- [Managed Side Effect Interpreters](https://awesome-repositories.com/f/software-engineering-architecture/side-effect-handlers/side-effect-execution-encapsulation/managed-side-effect-interpreters.md) — Performs mutations on application state or external systems through a controlled, auditable, and mockable execution layer. ([source](http://day8.github.io/re-frame/a-loop/))
- [Side Effect Registrars](https://awesome-repositories.com/f/software-engineering-architecture/side-effect-handlers/synchronous-effect-wrapping/side-effect-modeling/side-effect-registrars.md) — Associates a keyword with a function to perform an external action, such as updating local storage or making a network request. ([source](http://day8.github.io/re-frame/api-re-frame.core/))
- [Unidirectional Data Flow Architectures](https://awesome-repositories.com/f/software-engineering-architecture/software-architecture/architectural-patterns/layering-presentation/application-layer-architectures/state-management-architectures/action-reducer-architectures/unidirectional-data-flow-architectures.md) — Enforces a strict one-way loop where events update state and state updates trigger view changes. ([source](http://day8.github.io/re-frame/FAQs/DoINeedReFrame/))
- [Subscription-Based View Decouplers](https://awesome-repositories.com/f/software-engineering-architecture/software-architecture/architectural-patterns/modular-decoupled-design/decoupled-architectures/data-access-layers/view-state-projections/subscription-based-view-decouplers.md) — Uses a subscription model to layer data reactions so views only update when their specific dependencies change. ([source](http://day8.github.io/re-frame/FAQs/DoINeedReFrame/))
- [State Change Subscriptions](https://awesome-repositories.com/f/software-engineering-architecture/state-change-subscriptions.md) — Decouples UI components from the global state by delivering specific data slices that trigger renders only on change.
- [State Management Frameworks](https://awesome-repositories.com/f/software-engineering-architecture/state-management-frameworks.md) — Provides a centralized database and unidirectional data flow for managing application state in ClojureScript.
- [State Transition Mapping](https://awesome-repositories.com/f/software-engineering-architecture/state-transition-mapping.md) — Maps event identifiers to handler functions that update the application database or trigger side effects. ([source](http://day8.github.io/re-frame/api-intro/))
- [Document Object Interfaces](https://awesome-repositories.com/f/software-engineering-architecture/architectural-design-patterns/object-oriented-foundations/object-oriented-programming/structure-definitions/document-object-interfaces.md) — Uses data structures as a domain-specific language to represent and render document object model elements through an interpreter. ([source](http://day8.github.io/re-frame/data-oriented-design/))
- [Session Replay](https://awesome-repositories.com/f/software-engineering-architecture/architectural-design-patterns/state-management/persistence-and-serialization/state-serialization/session-replay.md) — Reproduces bugs by loading a known state checkpoint and re-processing logged events to reach specific error conditions. ([source](http://day8.github.io/re-frame/historical/))
- [Synchronous Event Cascades](https://awesome-repositories.com/f/software-engineering-architecture/asynchronous-event-dispatchers/reactive-event-dispatchers/synchronous-event-cascades.md) — Triggers asynchronous state changes and side effects while supporting synchronous execution for testing or diagnostic purposes. ([source](http://day8.github.io/re-frame/api-intro/))
- [Task Schedulers](https://awesome-repositories.com/f/software-engineering-architecture/client-server-architecture/long-running-task-protocols/task-schedulers.md) — Breaks CPU-intensive work into small chunks that yield control back to the browser. ([source](http://day8.github.io/re-frame/Solve-the-CPU-hog-problem/))
- [Modular Data Flow Management](https://awesome-repositories.com/f/software-engineering-architecture/component-architectures/modular-data-flow-management.md) — Deconstructs complex subscriptions into simpler, manageable data flows to streamline information movement. ([source](http://day8.github.io/re-frame/FAQs/alpha/))
- [Entity-Identified Component Instantiators](https://awesome-repositories.com/f/software-engineering-architecture/component-lifecycle-management/application-component-lifecycles/component-instantiation/entity-identified-component-instantiators.md) — Passes unique identifiers to components to render multiple instances of the same UI element for different data entities. ([source](http://day8.github.io/re-frame/reusable-components/))
- [Automated Dataflow Nodes](https://awesome-repositories.com/f/software-engineering-architecture/dataflow-frameworks/automated-dataflow-nodes.md) — Registers nodes that automatically resolve inputs, execute computations, and write results back to the global store. ([source](http://day8.github.io/re-frame/api-re-frame.alpha/))
- [Dataflow Node Registrars](https://awesome-repositories.com/f/software-engineering-architecture/dataflow-frameworks/automated-dataflow-nodes/dataflow-node-registrars.md) — Configures mechanisms for creating reactive graph nodes to enable complex data derivation. ([source](http://day8.github.io/re-frame/api-re-frame.alpha-instrumented/))
- [Dataflow Node Cleanups](https://awesome-repositories.com/f/software-engineering-architecture/dataflow-frameworks/dataflow-node-cleanups.md) — Deregisters specific flows and executes associated cleanup functions to remove data from the database. ([source](http://day8.github.io/re-frame/api-re-frame.alpha-instrumented/))
- [Declarative Effect Mapping](https://awesome-repositories.com/f/software-engineering-architecture/declarative-effect-mapping.md) — Describes state changes and side effects as data structures for an interpreter to execute instead of imperative calls.
- [Derived State Cleanup](https://awesome-repositories.com/f/software-engineering-architecture/derived-state-management/derived-state-cleanup.md) — Decouples the calculation and storage of derived data from the component render tree to allow independent persistence. ([source](http://day8.github.io/re-frame/flows-advanced-topics/))
- [Dynamic Execution Chain Modification](https://awesome-repositories.com/f/software-engineering-architecture/dynamic-execution-chain-modification.md) — Modifies internal processing queues and stacks at runtime to alter execution chains. ([source](http://day8.github.io/re-frame/Interceptors/))
- [Runtime Calculation Registries](https://awesome-repositories.com/f/software-engineering-architecture/dynamic-value-computations/runtime-calculation-registries.md) — Allows dynamic adaptation of dataflow graphs by registering or clearing calculation logic at runtime. ([source](http://day8.github.io/re-frame/Flows/))
- [Global Error Handlers](https://awesome-repositories.com/f/software-engineering-architecture/error-recovery/all-error-catchers/global-error-handlers.md) — Registers a global function to catch and process unhandled exceptions within the event processing pipeline. ([source](http://day8.github.io/re-frame/api-intro/))
- [Event-Driven Architectures](https://awesome-repositories.com/f/software-engineering-architecture/event-driven-architectures.md) — Processes application logic as a sequence of data-driven events and declarative side effects to ensure predictable state transitions.
- [Event Handler Composition](https://awesome-repositories.com/f/software-engineering-architecture/event-handler-composition.md) — Combines multiple logic units into single handlers by returning structured effect maps. ([source](http://day8.github.io/re-frame/FAQs/BestPractice/))
- [Global Event Interceptors](https://awesome-repositories.com/f/software-engineering-architecture/event-interception/global-event-interceptors.md) — Executes functions for every dispatched event to implement cross-cutting concerns like logging and auditing. ([source](http://day8.github.io/re-frame/FAQs/GlobalInterceptors/))
- [UI Event Dispatchers](https://awesome-repositories.com/f/software-engineering-architecture/event-interception/ui-event-dispatchers.md) — Overrides event handlers during dispatch to redirect or modify application behavior. ([source](http://day8.github.io/re-frame/api-re-frame.tooling/))
- [Execution Event Subscriptions](https://awesome-repositories.com/f/software-engineering-architecture/event-subscribers/process-event-subscriptions/execution-event-subscriptions.md) — Attaches source metadata to event and subscription registrations to identify trigger locations. ([source](http://day8.github.io/re-frame/api-re-frame.core-instrumented/))
- [External Resource Interceptors](https://awesome-repositories.com/f/software-engineering-architecture/external-content-handlers/external-content-inclusions/external-resource-references/external-resource-interceptors.md) — Creates an interceptor that fetches external dependencies and provides them to event handlers as coeffects. ([source](http://day8.github.io/re-frame/api-re-frame.core/))
- [Portable Feature Bundles](https://awesome-repositories.com/f/software-engineering-architecture/feature-based-project-structures/android-architectures/multi-module-architectures/feature-modules-with-routing/portable-feature-bundles.md) — Provides portable modules that bundle UI components with their required state subscriptions and event handlers for consistent reuse across applications. ([source](http://day8.github.io/re-frame/reusable-components/))
- [Finite State Machine Engines](https://awesome-repositories.com/f/software-engineering-architecture/finite-state-machine-engines.md) — Manages complex interface logic by treating application state and event handlers as a formal state machine to govern transitions. ([source](http://day8.github.io/re-frame/historical/))
- [Application State Machines](https://awesome-repositories.com/f/software-engineering-architecture/finite-state-machine-engines/application-state-machines.md) — Manages complex application logic by treating events as triggers and a centralized state database as the current state. ([source](http://day8.github.io/re-frame/historical/))
- [Frontend Architecture Patterns](https://awesome-repositories.com/f/software-engineering-architecture/frontend-architecture-patterns.md) — Structures large-scale applications with unidirectional data flow, decoupled business logic, and declarative side-effect handling.
- [Interceptor Pipelines](https://awesome-repositories.com/f/software-engineering-architecture/global-execution-handler-registration/handler-interceptor-pipelines/interceptor-pipelines.md) — Assigns sequences of interceptors to event handlers to modify execution behavior during registration. ([source](http://day8.github.io/re-frame/Interceptors/))
- [Data Dependency Graph Composition](https://awesome-repositories.com/f/software-engineering-architecture/integration-extensibility/dependency-injection/dependency-graph-construction/composable-graph-operators/data-dependency-graph-composition.md) — Links derived value calculations into dependency graphs to ensure correct update propagation. ([source](http://day8.github.io/re-frame/Flows/))
- [Event Handler Injection](https://awesome-repositories.com/f/software-engineering-architecture/integration-extensibility/dependency-injection/event-handler-injection.md) — Injects external dependencies or resources into an event handler's coeffects map using a registered handler. ([source](http://day8.github.io/re-frame/api-re-frame.core-instrumented/))
- [Event Resource Interceptors](https://awesome-repositories.com/f/software-engineering-architecture/integration-extensibility/dependency-injection/event-handler-injection/event-resource-interceptors.md) — Creates interceptors that provide external resources like timestamps or random numbers to event handlers via coeffects. ([source](http://day8.github.io/re-frame/api-re-frame.core/))
- [External Data Injections](https://awesome-repositories.com/f/software-engineering-architecture/integration-extensibility/dependency-injection/event-handler-injection/external-data-injections.md) — Registers and injects external state or environment values into event handlers to ensure they have the necessary context to perform their logic. ([source](http://day8.github.io/re-frame/Coeffects/))
- [Function Interceptors](https://awesome-repositories.com/f/software-engineering-architecture/integration-extensibility/extensibility/plugin-architectures/developer-authoring-interfaces/custom-module-implementations/module-functionality-extenders/function-interceptors.md) — Builds reusable middleware with before and after functions to modify event contexts or effects. ([source](http://day8.github.io/re-frame/api-re-frame.core-instrumented/))
- [Stateful Component Wrappers](https://awesome-repositories.com/f/software-engineering-architecture/integration-interfaces/ui-component-integrations/external-component-integration/stateful-component-wrappers.md) — Wraps external stateful components in lifecycle containers that synchronize application state with the component's internal imperative commands. ([source](http://day8.github.io/re-frame/Using-Stateful-JS-Components/))
- [User Action Intents](https://awesome-repositories.com/f/software-engineering-architecture/intent-based-coordination/intent-to-action-handlers/user-action-intents.md) — Transforms low-level DOM events into high-level data descriptions of user intent to simplify application logic. ([source](http://day8.github.io/re-frame/FAQs/Null-Dispatched-Events/))
- [Incremental Task Processors](https://awesome-repositories.com/f/software-engineering-architecture/long-running-process-compatibility-analysis/incremental-task-processors.md) — Breaks intensive computations into smaller, incremental chunks that yield control back to the browser. ([source](http://day8.github.io/re-frame/Solve-the-CPU-hog-problem/))
- [Event History Replayers](https://awesome-repositories.com/f/software-engineering-architecture/missed-execution-handlers/event-history-replayers.md) — Reproduces application states by applying a sequence of logged events to a known state checkpoint. ([source](http://day8.github.io/re-frame/historical/))
- [Function Composition](https://awesome-repositories.com/f/software-engineering-architecture/modular-program-composition/function-composition.md) — Threads data through a sequence of functions using queues, routers, interceptors, and signal graphs. ([source](http://day8.github.io/re-frame/interconnections/))
- [Programmatic Value Injection](https://awesome-repositories.com/f/software-engineering-architecture/programmatic-value-injection.md) — Resolves a subscription's current value and passes it into an event handler to decouple data fetching from business logic. ([source](http://day8.github.io/re-frame/FAQs/UseASubscriptionInAnEventHandler/))
- [Interceptor-Based Value Injections](https://awesome-repositories.com/f/software-engineering-architecture/programmatic-value-injection/interceptor-based-value-injections.md) — Resolves subscription values via interceptors and passes them directly into event handlers. ([source](http://day8.github.io/re-frame/FAQs/UseASubscriptionInAnEventHandler/))
- [Reactive Data Streams](https://awesome-repositories.com/f/software-engineering-architecture/reactive-data-streams.md) — Returns signals that reactively deliver streams of values based on registered queries. ([source](http://day8.github.io/re-frame/api-re-frame.alpha-instrumented/))
- [Reactivity Dependency Graphs](https://awesome-repositories.com/f/software-engineering-architecture/reactivity-dependency-graphs.md) — Creates a dependency graph where a derivation can use the output of other derivations as its own input. ([source](http://day8.github.io/re-frame/Flows/))
- [Process Interruption](https://awesome-repositories.com/f/software-engineering-architecture/rpc-cancellation/asynchronous-operation-cancellation/process-interruption.md) — Checks for cancellation flags during iterative task execution to stop long-running operations upon user request. ([source](http://day8.github.io/re-frame/Solve-the-CPU-hog-problem/))
- [Runtime Handler Registration](https://awesome-repositories.com/f/software-engineering-architecture/runtime-handler-registration.md) — Defines the logic used to compute and cache specific views of the application state. ([source](http://day8.github.io/re-frame/api-intro/))
- [State Tree Relative Path Calculators](https://awesome-repositories.com/f/software-engineering-architecture/runtime-path-resolvers/path-normalizers/path-relation-calculations/state-tree-relative-path-calculators.md) — Returns an interceptor that narrows the state provided to a handler to a specific sub-path and grafts the result back. ([source](http://day8.github.io/re-frame/api-re-frame.core/))
- [Dynamic Derivation Updates](https://awesome-repositories.com/f/software-engineering-architecture/runtime-schema-derivation/dynamic-derivation-updates.md) — Allows re-registering derivation logic at runtime to update calculations without restarting the application. ([source](http://day8.github.io/re-frame/Flows/))
- [Sequential Effect Execution](https://awesome-repositories.com/f/software-engineering-architecture/sequential-computation-array-execution/sequential-effect-execution.md) — Executes multiple side effects in a specific order to support complex workflows and conditional execution. ([source](http://day8.github.io/re-frame/api-builtin-effects/))
- [Algebraic Effect Handlers](https://awesome-repositories.com/f/software-engineering-architecture/side-effect-handlers/algebraic-effect-handlers.md) — Registers functions to specific keys so that named effects trigger corresponding pieces of logic. ([source](http://day8.github.io/re-frame/Effects/))
- [Handler Overrides](https://awesome-repositories.com/f/software-engineering-architecture/side-effect-handlers/handler-overrides.md) — Allows temporary substitution of effect handlers during dispatch cascades to facilitate testing and dry-runs. ([source](http://day8.github.io/re-frame/api-re-frame.core/))
- [Application State Stores](https://awesome-repositories.com/f/software-engineering-architecture/single-source-of-truth-modeling/application-state-stores.md) — Maintains a centralized, immutable data structure that serves as the authoritative source of truth for the application. ([source](http://day8.github.io/re-frame/Loading-Initial-Data/))
- [Action-to-Handler Mappings](https://awesome-repositories.com/f/software-engineering-architecture/software-architecture/architectural-patterns/layering-presentation/application-layer-architectures/state-management-architectures/action-reducer-architectures/colocated-action-reducers/action-to-handler-mappings.md) — Triggers side effects or additional computations after event handlers complete to validate state. ([source](http://day8.github.io/re-frame/Interceptors/))
- [State Change Observers](https://awesome-repositories.com/f/software-engineering-architecture/state-change-observers.md) — Triggers computations and updates state paths whenever observed data in the database changes. ([source](http://day8.github.io/re-frame/api-re-frame.core/))
- [Path-Based State Observers](https://awesome-repositories.com/f/software-engineering-architecture/state-change-observers/path-based-state-observers.md) — Computes and stores a new value in the database whenever specific paths within the state are modified. ([source](http://day8.github.io/re-frame/api-re-frame.core-instrumented/))
- [State Machine Integrations](https://awesome-repositories.com/f/software-engineering-architecture/state-machine-logic/lightweight-state-machines/automation-state-machines/entity-state-machines/application-state-machines/state-machine-integrations.md) — Manages complex application logic and transitions using formal state machine definitions. ([source](http://day8.github.io/re-frame/External-Resources/))
- [Stream Event Interception](https://awesome-repositories.com/f/software-engineering-architecture/stream-event-interception.md) — Executes logic on every event in the application flow to support observability and cross-cutting concerns. ([source](http://day8.github.io/re-frame/FAQs/GlobalInterceptors/))
- [Global Event Interceptors](https://awesome-repositories.com/f/software-engineering-architecture/stream-event-interception/global-event-interceptors.md) — Executes a shared piece of logic before every event to perform tasks like logging or auditing across the entire application. ([source](http://day8.github.io/re-frame/FAQs/GlobalInterceptors/))
- [Subscription Lifecycle Management](https://awesome-repositories.com/f/software-engineering-architecture/subscription-lifecycle-management.md) — Manages the creation and disposal of data subscriptions to prevent memory leaks and optimize performance. ([source](http://day8.github.io/re-frame/FAQs/alpha/))
- [Synchronous Event Dispatch Loops](https://awesome-repositories.com/f/software-engineering-architecture/synchronous-event-dispatch-loops.md) — Executes event handlers immediately as function calls to ensure state updates complete before subsequent operations. ([source](http://day8.github.io/re-frame/Loading-Initial-Data/))
- [State-Driven View Transitions](https://awesome-repositories.com/f/software-engineering-architecture/tree-traversal-algorithms/tree-based-hierarchical-navigation/navigation-state-trees/hierarchical-view-navigation/state-driven-view-transitions.md) — Switches between different application panels by updating a central state key and triggering reactive view changes. ([source](http://day8.github.io/re-frame/App-Structure/))

### Web Development

- [ClojureScript-React Bridges](https://awesome-repositories.com/f/web-development/clojurescript-react-bridges.md) — Provides a functional framework for building user interfaces using ClojureScript and React with unidirectional data flow.
- [Centralized State Management](https://awesome-repositories.com/f/web-development/hydration-state-management/browser-side-state-management/centralized-state-management.md) — Stores all application data in a single in-memory database to allow for atomic transactions and consistent querying. ([source](http://day8.github.io/re-frame/application-state/))
- [Single-Page Applications](https://awesome-repositories.com/f/web-development/single-page-applications.md) — Provides a functional architecture for building scalable single-page applications with centralized state management. ([source](http://day8.github.io/re-frame/start-coding/))
- [ClojureScript Implementations](https://awesome-repositories.com/f/web-development/single-page-applications/clojurescript-implementations.md) — Provides a functional framework for building single-page applications using ClojureScript and React with a centralized immutable database.
- [Application Route Managers](https://awesome-repositories.com/f/web-development/application-route-managers.md) — Navigates between different application views and manages browser history using bidirectional routing mechanisms. ([source](http://day8.github.io/re-frame/External-Resources/))
- [Derived State](https://awesome-repositories.com/f/web-development/derived-state.md) — Calculates values based on application state to build a dependency graph of materialized views. ([source](http://day8.github.io/re-frame/subscriptions/))
- [Effect Handlers](https://awesome-repositories.com/f/web-development/effect-handlers.md) — Links functions to unique identifiers to trigger logic automatically in response to reactive state changes. ([source](http://day8.github.io/re-frame/api-re-frame.alpha-instrumented/))
- [Side Effect Decoupling](https://awesome-repositories.com/f/web-development/event-driven-architectures/side-effect-decoupling.md) — Decouples side effects from state changes by emitting events for asynchronous processing. ([source](http://day8.github.io/re-frame/Effects/))
- [External Side Effect Dispatching](https://awesome-repositories.com/f/web-development/external-side-effect-dispatching.md) — Maps unique identifiers to functions that execute external actions whenever specific application events occur. ([source](http://day8.github.io/re-frame/api-re-frame.core/))
- [Functional Frontend Frameworks](https://awesome-repositories.com/f/web-development/functional-frontend-development/functional-frontend-frameworks.md) — Provides a toolset for building single-page applications that decouples business logic from the view layer using pure functions and interceptor pipelines.
- [React State Bindings](https://awesome-repositories.com/f/web-development/react-state-bindings.md) — Connects external state management containers to React UI components to decouple business logic.
- [Event-Driven State Handlers](https://awesome-repositories.com/f/web-development/state-update-handlers/state-synchronization-handlers/event-driven-state-handlers.md) — Associates an event ID with a function that computes a new application state based on the current state and event data. ([source](http://day8.github.io/re-frame/api-re-frame.core/))
- [Web Application Frameworks](https://awesome-repositories.com/f/web-development/web-application-frameworks.md) — Provides a toolset for building single-page applications that treat logic as a sequence of data-driven events.
- [Query Lifecycle Management](https://awesome-repositories.com/f/web-development/asynchronous-request-managers/query-lifecycle-management.md) — Controls how dataflow nodes are created and cached to improve the performance of repeated subscriptions. ([source](http://day8.github.io/re-frame/api-re-frame.alpha-instrumented/))
- [Cache Invalidation Strategies](https://awesome-repositories.com/f/web-development/cache-invalidation-strategies.md) — Triggers the disposal of active subscriptions to clear stale state and ensure fresh data retrieval. ([source](http://day8.github.io/re-frame/FAQs/Why-Clear-Sub-Cache/))
- [Dependent Flow Composition](https://awesome-repositories.com/f/web-development/data-flow-architectures/taint-analysis-engines/inter-procedural-data-flow/data-dependency-analysis/dependent-flow-composition.md) — Links data transformation nodes into dependency graphs to ensure downstream calculations execute after upstream updates. ([source](http://day8.github.io/re-frame/Flows/))
- [Reactive Dependency Chains](https://awesome-repositories.com/f/web-development/dependent-data-fetching/reactive-dependency-chains.md) — Links derived value calculations into a dependency graph to ensure consistent state updates. ([source](http://day8.github.io/re-frame/Flows/))
- [Effect Queuing Pipelines](https://awesome-repositories.com/f/web-development/effect-schedulers/effect-queuing-pipelines.md) — Executes a sequence of distinct side effects in a specific order to coordinate complex application behaviors. ([source](http://day8.github.io/re-frame/api-builtin-effects/))
- [State-Driven Event Subscriptions](https://awesome-repositories.com/f/web-development/event-binding/state-driven-event-subscriptions.md) — Resolves the current value of a subscription and makes it available within event handlers to facilitate data-driven updates. ([source](http://day8.github.io/re-frame/FAQs/UseASubscriptionInAnEventHandler/))
- [Event Argument Encapsulations](https://awesome-repositories.com/f/web-development/event-delegation/data-attribute-event-mapping/event-argument-encapsulations.md) — Uses maps instead of positional vectors for event data to improve code maintainability and reduce fragility. ([source](http://day8.github.io/re-frame/FAQs/BestPractice/))
- [Form State Management](https://awesome-repositories.com/f/web-development/form-state-management.md) — Handles the lifecycle, validation, and submission of user input fields within the application state. ([source](http://day8.github.io/re-frame/External-Resources/))
- [Identity-Parameterized State Managers](https://awesome-repositories.com/f/web-development/frontend-development-tools/state-data-management/component-lifecycle-utilities/component-state-management/identity-parameterized-state-managers.md) — Renders multiple instances of a component by passing unique identifiers to parameterize data subscriptions and event dispatches. ([source](http://day8.github.io/re-frame/reusable-components/))
- [Instance Stream Isolators](https://awesome-repositories.com/f/web-development/frontend-development-tools/state-data-management/component-lifecycle-utilities/component-state-management/instance-identifiers/instance-stream-isolators.md) — Isolates data subscriptions and event dispatches for multiple instances of the same component using unique identifiers. ([source](http://day8.github.io/re-frame/reusable-components/))
- [Undo-Redo History](https://awesome-repositories.com/f/web-development/history-management/undo-redo-history.md) — Tracks historical states of the application to allow users to revert previous actions. ([source](http://day8.github.io/re-frame/External-Resources/))
- [Main Thread Offloading](https://awesome-repositories.com/f/web-development/main-thread-offloading.md) — Offloads heavy computations to background threads to keep the main user interface responsive. ([source](http://day8.github.io/re-frame/External-Resources/))
- [React-Compatible Frameworks](https://awesome-repositories.com/f/web-development/react-compatible-frameworks.md) — Acts as a functional wrapper for React that decouples business logic and state management from the view layer.
- [Server-Side Rendering](https://awesome-repositories.com/f/web-development/rendering-templating/server-side-rendering.md) — Pre-renders views on the server or via headless browsers to improve initial load times and search engine indexing. ([source](http://day8.github.io/re-frame/External-Resources/))
- [Query Deduplications](https://awesome-repositories.com/f/web-development/request-deduplication/query-deduplications.md) — Collapses redundant data requests into single computation nodes to protect underlying sources and improve performance. ([source](http://day8.github.io/re-frame/correcting-a-wrong/))
- [Cross-Cutting Concerns](https://awesome-repositories.com/f/web-development/request-middleware-pipelines/service-middleware-pipelines/cross-cutting-concerns.md) — Provides middleware interceptors to inject cross-cutting logic like logging and debugging into the event processing pipeline. ([source](http://day8.github.io/re-frame/FAQs/DoINeedReFrame/))
- [Interceptor-Based](https://awesome-repositories.com/f/web-development/request-middleware-pipelines/service-middleware-pipelines/cross-cutting-concerns/interceptor-based.md) — Uses interceptors to inject shared logic like logging, debugging, or validation into event handlers without cluttering core business logic. ([source](http://day8.github.io/re-frame/FAQs/DoINeedReFrame/))
- [Task Chunking](https://awesome-repositories.com/f/web-development/rest-apis/api-response-validation/long-running-task-endpoints/long-running-operation-polling/long-running-research-task-pollers/task-chunking.md) — Breaks heavy CPU tasks into smaller units of work to maintain UI responsiveness and animation smoothness. ([source](http://day8.github.io/re-frame/Solve-the-CPU-hog-problem/))
- [Server-Side Rendering Pipelines](https://awesome-repositories.com/f/web-development/server-side-rendering-pipelines.md) — Generates initial HTML on the server to improve SEO and speed up the first paint. ([source](http://day8.github.io/re-frame/External-Resources/))
- [State Initialization](https://awesome-repositories.com/f/web-development/state-initialization.md) — Populates the global state database with default values or server responses to ensure the UI has necessary data. ([source](http://day8.github.io/re-frame/Loading-Initial-Data/))
- [Synchronous State Updates](https://awesome-repositories.com/f/web-development/state-update-handlers/debounced-state-updates/immediate-state-updates/synchronous-state-updates.md) — Executes state updates synchronously to maintain responsiveness and prevent race conditions during rapid user input. ([source](http://day8.github.io/re-frame/FAQs/laggy-input/))
- [Virtual DOM Reconciliation](https://awesome-repositories.com/f/web-development/virtual-dom-reconciliation/virtual-dom-reconciliation.md) — Transforms state-driven data structures into a virtual representation to efficiently update the user interface.
- [Web Worker Orchestrators](https://awesome-repositories.com/f/web-development/web-worker-orchestrators.md) — Offloads heavy computations to background threads to keep the user interface responsive. ([source](http://day8.github.io/re-frame/External-Resources/))

### Part of an Awesome List

- [Application Architecture and Logic](https://awesome-repositories.com/f/awesome-lists/devtools/application-architecture-and-logic.md) — Orchestrates data flow between functional components using event routers and signal graphs. ([source](http://day8.github.io/re-frame/interconnections/))
- [Scoping](https://awesome-repositories.com/f/awesome-lists/data/database-access/scoping.md) — Limits an event handler's view to a specific sub-path of the database and automatically grafts the result back. ([source](http://day8.github.io/re-frame/api-re-frame.core-instrumented/))
- [State Reconstruction](https://awesome-repositories.com/f/awesome-lists/data/experiment-tracking/state-reconstruction.md) — Reconstructs application state by applying logged events to a checkpoint for time-travel debugging. ([source](http://day8.github.io/re-frame/historical/))
- [Project Documentation Examples](https://awesome-repositories.com/f/awesome-lists/devtools/project-documentation-examples.md) — Presents a comprehensive essay on philosophy and ecosystem.
- [React Interface](https://awesome-repositories.com/f/awesome-lists/media/react-interface.md) — Framework for building single-page applications with reactive state.

### Business & Productivity Software

- [Application State Syncing](https://awesome-repositories.com/f/business-productivity-software/cloud-synced-managers/playback-state-syncing/library-state-syncing/application-state-syncing.md) — Retrieves reactive data from the application store by mapping queries to handlers, allowing components to automatically update. ([source](http://day8.github.io/re-frame/FAQs/alpha/))

### Data & Databases

- [Application State Management](https://awesome-repositories.com/f/data-databases/application-state-management.md) — Provides a centralized, immutable database that serves as the single source of truth for the entire application state. ([source](http://day8.github.io/re-frame/a-loop/))
- [Global Application State](https://awesome-repositories.com/f/data-databases/application-state-management/global-application-state.md) — Stores all application data in a single, centralized in-memory database to enable consistent querying and atomic transformations. ([source](http://day8.github.io/re-frame/application-state/))
- [Global State Update Handlers](https://awesome-repositories.com/f/data-databases/application-state-management/global-application-state/global-state-update-handlers.md) — Sets the central data store to a new value to synchronize the application state across the user interface. ([source](http://day8.github.io/re-frame/api-builtin-effects/))
- [Automated State Derivations](https://awesome-repositories.com/f/data-databases/automated-state-derivations.md) — Calculates and updates application state automatically by chaining reactive data transformations. ([source](http://day8.github.io/re-frame/subscriptions/))
- [Transactional Event Processing](https://awesome-repositories.com/f/data-databases/key-value-stores/atomic-key-updaters/atomic-state-transitions/transactional-event-processing.md) — Executes state updates in discrete, transactional units to ensure the application never exists in an inconsistent intermediate state between events. ([source](http://day8.github.io/re-frame/on-dynamics/))
- [Reactive Data Queries](https://awesome-repositories.com/f/data-databases/reactive-data-queries.md) — Provides reactive queries that automatically trigger interface updates when underlying application state changes. ([source](http://day8.github.io/re-frame/api-re-frame.core/))
- [Reactive Derivations](https://awesome-repositories.com/f/data-databases/secondary-indexes/derived-data-generation/reactive-derivations.md) — Create an interceptor that computes a new database value whenever specific paths in the database change. ([source](http://day8.github.io/re-frame/api-re-frame.core-instrumented/))
- [State-Driven Data Flow Architectures](https://awesome-repositories.com/f/data-databases/state-driven-data-flow-architectures.md) — Coordinates data movement between functions using signal graphs to ensure predictable state transitions. ([source](http://day8.github.io/re-frame/interconnections/))
- [State Inspection Interfaces](https://awesome-repositories.com/f/data-databases/application-state-management/state-inspection-interfaces.md) — Provides visual tools for tracking and displaying real-time state changes and data flow within an application. ([source](http://day8.github.io/re-frame/FAQs/Inspecting-app-db/))
- [Synchronous State Synchronizers](https://awesome-repositories.com/f/data-databases/cloud-storage-sync-tools/application-state-syncs/synchronous-state-synchronizers.md) — Executes event handlers immediately and synchronously to guarantee state is initialized before views are mounted. ([source](http://day8.github.io/re-frame/Loading-Initial-Data/))
- [Path-Narrowing Interceptors](https://awesome-repositories.com/f/data-databases/data-access-providers/path-narrowing-interceptors.md) — Provides an interceptor that restricts an event handler's view to a specific path within the application database. ([source](http://day8.github.io/re-frame/api-re-frame.core-instrumented/))
- [Subscription Cache Invalidators](https://awesome-repositories.com/f/data-databases/data-caching/persistent-binary-caches/cache-clearing/subscription-cache-invalidators.md) — Invalidates all stored subscription results to ensure updated logic is applied after a code reload. ([source](http://day8.github.io/re-frame/FAQs/Why-Clear-Sub-Cache/))
- [Subscription Cache Managers](https://awesome-repositories.com/f/data-databases/data-caching/persistent-binary-caches/cache-clearing/subscription-cache-managers.md) — Provides utilities to manage and clear subscription caches, ensuring data consistency during development and runtime. ([source](http://day8.github.io/re-frame/api-re-frame.core-instrumented/))
- [Data Change Callbacks](https://awesome-repositories.com/f/data-databases/data-change-callbacks.md) — Computes new database values via callbacks whenever specific paths in the application state are modified. ([source](http://day8.github.io/re-frame/api-re-frame.core-instrumented/))
- [Data Change Subscriptions](https://awesome-repositories.com/f/data-databases/data-change-subscriptions.md) — Observes specific database paths and automatically computes and stores new values when those paths change. ([source](http://day8.github.io/re-frame/api-re-frame.core-instrumented/))
- [Subscription Deduplicators](https://awesome-repositories.com/f/data-databases/data-change-subscriptions/subscription-deduplicators.md) — Shares the result of a single expensive data computation across multiple components to avoid redundant processing. ([source](http://day8.github.io/re-frame/correcting-a-wrong/))
- [Subscription Cache Managers](https://awesome-repositories.com/f/data-databases/data-engineering-infrastructure/caching-performance/caching-strategies/query-result-caching/cache-consistency-managers/subscription-cache-managers.md) — Clears cached results or unregisters specific handlers to ensure data consistency. ([source](http://day8.github.io/re-frame/api-re-frame.core-instrumented/))
- [Client-Side Storage Persistence](https://awesome-repositories.com/f/data-databases/data-engineering-infrastructure/data-persistence-storage/data-storage/client-side-persistence/client-side-storage-persistence.md) — Saves and retrieves application state from local storage to maintain user data across sessions. ([source](http://day8.github.io/re-frame/External-Resources/))
- [Frontend State Normalization](https://awesome-repositories.com/f/data-databases/data-normalization/frontend-state-normalization.md) — Structures complex data into flat, relational maps within the central store to mirror server-side database schemas and simplify data updates. ([source](http://day8.github.io/re-frame/FAQs/DB_Normalisation/))
- [Data Querying Interfaces](https://awesome-repositories.com/f/data-databases/data-querying-interfaces.md) — Retrieves specific slices of the global state through subscriptions to decouple data logic from the user interface. ([source](http://day8.github.io/re-frame/App-Structure/))
- [Query Parameter Filters](https://awesome-repositories.com/f/data-databases/data-querying/query-parameter-filters.md) — Retrieves processed data from the application state using keys and custom parameters to filter or transform the result. ([source](http://day8.github.io/re-frame/FAQs/alpha/))
- [Database Change Tracking](https://awesome-repositories.com/f/data-databases/database-change-tracking.md) — Monitors specific database paths and automatically computes new values when those paths change. ([source](http://day8.github.io/re-frame/api-re-frame.core/))
- [Global State Coordination](https://awesome-repositories.com/f/data-databases/distributed-key-value-stores/global-state-coordination.md) — Coordinates a data-oriented flow where UI components subscribe to derived values and trigger changes via events. ([source](https://cdn.jsdelivr.net/gh/day8/re-frame@master/README.md))
- [External Data Subscriptions](https://awesome-repositories.com/f/data-databases/external-data-integrations/external-data-subscriptions.md) — Connects application state to external data sources by managing query lifecycles and handling updates. ([source](http://day8.github.io/re-frame/Subscribing-To-External-Data/))
- [Database Path Grafting](https://awesome-repositories.com/f/data-databases/external-storage-integrations/database-access-layers/database-path-grafting.md) — Restricts an event handler's view to a specific sub-path of the database and grafts changes back automatically. ([source](http://day8.github.io/re-frame/api-re-frame.core-instrumented/))
- [Materialized Views](https://awesome-repositories.com/f/data-databases/materialized-views.md) — Computes multi-layered materialized views of application state using a deduplicated signal graph. ([source](http://day8.github.io/re-frame/a-loop/))
- [Active Query Inspections](https://awesome-repositories.com/f/data-databases/query-performance-monitors/active-query-inspections.md) — Lists all currently active query vectors and maps them to their respective reactions for inspection. ([source](http://day8.github.io/re-frame/Debugging/))
- [Query Handler Registrations](https://awesome-repositories.com/f/data-databases/reactive-data-queries/query-handler-registrations.md) — Maps unique identifiers to functions that process and return reactive data streams. ([source](http://day8.github.io/re-frame/api-re-frame.alpha/))
- [Reactive Query De-duplicators](https://awesome-repositories.com/f/data-databases/reactive-data-queries/reactive-query-de-duplicators.md) — Shares a single computation node across multiple subscribers to avoid redundant expensive operations. ([source](http://day8.github.io/re-frame/correcting-a-wrong/))
- [Remote Data Fetching](https://awesome-repositories.com/f/data-databases/remote-data-fetching.md) — Queries remote data sources within a subscription and manages the lifecycle of the request, including automatic cleanup. ([source](http://day8.github.io/re-frame/Subscribing-To-External-Data/))
- [Persistent State Flows](https://awesome-repositories.com/f/data-databases/state-driven-data-flow-architectures/persistent-state-flows.md) — Decouples data lifecycles from UI components by defining persistent, state-derived values that exist independently of the view tree. ([source](http://day8.github.io/re-frame/flows-advanced-topics/))
- [Browser Session Data Management](https://awesome-repositories.com/f/data-databases/stateful-session-management/browser-session-data-management.md) — Reads and writes data to cookies, local storage, and document attributes to persist application state across sessions. ([source](http://day8.github.io/re-frame/External-Resources/))
- [Subscription-Based External Data Queries](https://awesome-repositories.com/f/data-databases/subscription-based-external-data-queries.md) — Connects the application state to remote data sources by triggering queries when a subscription is activated and cleaning up resources when disposed. ([source](http://day8.github.io/re-frame/Subscribing-To-External-Data/))

### Development Tools & Productivity

- [State-Change Reactive Flows](https://awesome-repositories.com/f/development-tools-productivity/input-mapping-layers/reactive/state-change-reactive-flows.md) — Registers automated data processing tasks that resolve inputs and persist results whenever state changes. ([source](http://day8.github.io/re-frame/api-re-frame.alpha-instrumented/))
- [Application Error Handling](https://awesome-repositories.com/f/development-tools-productivity/application-error-handling.md) — Captures and processes exceptions during event dispatch to prevent application crashes. ([source](http://day8.github.io/re-frame/api-intro/))
- [Application State Restorations](https://awesome-repositories.com/f/development-tools-productivity/application-state-restorations.md) — Checkpoints the current state of the database and subscriptions to allow reverting to a previous state. ([source](http://day8.github.io/re-frame/api-re-frame.core/))
- [Undo-Redo State History](https://awesome-repositories.com/f/development-tools-productivity/change-tracking/state-tracking-utilities/action-based-state-tracking/undo-redo-state-history.md) — Tracks state changes over time to allow users to revert actions and restore previous application states. ([source](http://day8.github.io/re-frame/External-Resources/))
- [Debugging and Inspection Tools](https://awesome-repositories.com/f/development-tools-productivity/debugging-profiling-testing/debugging-diagnostics/debugging-inspection-tools/debugging-and-inspection-tools.md) — Offers interactive tools that allow developers to inspect, monitor, and troubleshoot application state and execution. ([source](http://day8.github.io/re-frame/External-Resources/))
- [Event Sourcing Engines](https://awesome-repositories.com/f/development-tools-productivity/deterministic-record-and-replay-frameworks/event-sourcing-engines.md) — Records sequences of events to allow the exact reconstruction of system state for error reproduction. ([source](http://day8.github.io/re-frame/historical/))
- [Parameterized Component Initializers](https://awesome-repositories.com/f/development-tools-productivity/instance-initialization/component-instance-initializers/parameterized-component-initializers.md) — Enables the creation of multiple component instances by passing unique identifiers to configure their specific data entities and logic. ([source](http://day8.github.io/re-frame/reusable-components/))
- [Parameterized Instance Initializers](https://awesome-repositories.com/f/development-tools-productivity/instance-initialization/component-instance-initializers/parameterized-instance-initializers.md) — Renders multiple instances of the same component by passing unique identities to ensure each manages its own specific data entity. ([source](http://day8.github.io/re-frame/reusable-components/))
- [Query Execution Tracing](https://awesome-repositories.com/f/development-tools-productivity/query-execution-tracing.md) — Logs internal execution steps and query logic to diagnose performance and logical errors during development. ([source](http://day8.github.io/re-frame/api-intro/))
- [Source Line Tracking](https://awesome-repositories.com/f/development-tools-productivity/source-line-tracking.md) — Records source file and line metadata for events and subscriptions to facilitate diagnostic tracking. ([source](http://day8.github.io/re-frame/api-re-frame.alpha-instrumented/))
- [Event-to-Source Mapping](https://awesome-repositories.com/f/development-tools-productivity/source-map-generators/event-to-source-mapping.md) — Links runtime events and subscriptions back to original source code locations in debug builds. ([source](http://day8.github.io/re-frame/api-re-frame.alpha-instrumented/))
- [State Debugging Tools](https://awesome-repositories.com/f/development-tools-productivity/state-debugging-tools.md) — Provides development tools for monitoring and inspecting application state and data flow during runtime. ([source](https://cdn.jsdelivr.net/gh/day8/re-frame@master/README.md))
- [Subscription Management](https://awesome-repositories.com/f/development-tools-productivity/subscription-management.md) — Registers and unregisters data subscriptions and clears the subscription cache to support hot-reloading. ([source](http://day8.github.io/re-frame/api-re-frame.core-instrumented/))
- [Trace Event Emissions](https://awesome-repositories.com/f/development-tools-productivity/trace-event-emissions.md) — Provides a stream of trace records for analyzing the sequence and flow of application events. ([source](http://day8.github.io/re-frame/api-re-frame.tooling/))
- [Pure Event Handler Validators](https://awesome-repositories.com/f/development-tools-productivity/validation-logic/logic-validation-frameworks/pure-event-handler-validators.md) — Validates business logic by executing event handlers as pure functions independently of the application state. ([source](http://day8.github.io/re-frame/Testing/))

### Graphics & Multimedia

- [UI Component Rendering](https://awesome-repositories.com/f/graphics-multimedia/graphics-engines-rendering/rendering/systems/dom-web-rendering-strategies/ui-component-rendering.md) — Generates user interfaces using components that automatically re-render when subscribed state changes. ([source](http://day8.github.io/re-frame/a-loop/))

### Operating Systems & Systems Programming

- [Reactive Subscription Queries](https://awesome-repositories.com/f/operating-systems-systems-programming/register-state-inspectors/reactive-subscription-queries.md) — Derives and caches data from the application state for reactive use in the user interface. ([source](http://day8.github.io/re-frame/api-re-frame.alpha-instrumented/))

### Programming Languages & Runtimes

- [Event Settlement Tracking](https://awesome-repositories.com/f/programming-languages-runtimes/all-settlement-synchronization/event-settlement-tracking.md) — Tracks when a dispatched event and all its synchronous child effects have completed. ([source](http://day8.github.io/re-frame/api-re-frame.core/))
- [External Dependency Injections](https://awesome-repositories.com/f/programming-languages-runtimes/function-argument-passing/dependency-argument-injection/external-dependency-injections.md) — Provides a map of required computational resources and external data to handlers as arguments. ([source](http://day8.github.io/re-frame/Coeffects/))
- [Functional Event Callbacks](https://awesome-repositories.com/f/programming-languages-runtimes/higher-order-function-toolkits/functional-event-callbacks.md) — Memoizes event handler functions to prevent unnecessary re-renders while supporting dynamic arguments. ([source](http://day8.github.io/re-frame/on-stable-dom-handlers/))
- [Stable Callback Generators](https://awesome-repositories.com/f/programming-languages-runtimes/higher-order-function-toolkits/functional-event-callbacks/stable-callback-generators.md) — Reuses stable callback functions instead of recreating anonymous functions to prevent unnecessary re-renders. ([source](http://day8.github.io/re-frame/on-stable-dom-handlers/))
- [Event-Driven Lineage](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-safety/end-to-end/data-lineage-graphs/event-driven-lineage.md) — Processes real-time pipeline events to update dependency graphs and visualize data flow provenance. ([source](http://day8.github.io/re-frame/Debugging/))
- [Portable Feature Modules](https://awesome-repositories.com/f/programming-languages-runtimes/module-and-package-management/portable-feature-modules.md) — Groups a UI component with its associated state subscriptions and event handlers to create a portable unit of reuse. ([source](http://day8.github.io/re-frame/reusable-components/))
- [Pure Functions](https://awesome-repositories.com/f/programming-languages-runtimes/pure-functions.md) — Constructs user interfaces as side-effect-free functions that react to data changes. ([source](http://day8.github.io/re-frame/FAQs/DoINeedReFrame/))
- [Conditional Flow Execution](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-effect-execution/conditional-execution/conditional-flow-execution.md) — Executes calculations conditionally based on predicates derived from live inputs. ([source](http://day8.github.io/re-frame/Flows/))

### Scientific & Mathematical Computing

- [Reactive Signal Query Registration](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/algorithms-and-complexity/algorithms/graph-processing/shortest-path-algorithms/a-star-search/reactive-signal-query-registration.md) — Defines a mechanism to derive a specific value from the application state, creating a reusable node in a reactive signal graph. ([source](http://day8.github.io/re-frame/api-re-frame.core/))

### Testing & Quality Assurance

- [Side Effect Isolation](https://awesome-repositories.com/f/testing-quality-assurance/general-testing-utilities/test-isolation/logic-isolation-utilities/business-logic-isolation/side-effect-isolation.md) — Overrides specific effect handlers during event dispatch to test logic in isolation without triggering real-world actions. ([source](https://day8.github.io/re-frame/Debugging/))
- [Subscription Logic Testers](https://awesome-repositories.com/f/testing-quality-assurance/api-network-testing/api-testing/graphql-testing/subscription-testing-tools/subscription-logic-testers.md) — Verifies data transformation logic by passing mock state values into subscription handlers. ([source](http://day8.github.io/re-frame/Testing/))
- [Dependency Mocking](https://awesome-repositories.com/f/testing-quality-assurance/dependency-mocking.md) — Simulates external system behavior by substituting real components with controlled mock implementations during testing. ([source](http://day8.github.io/re-frame/Coeffects/))
- [Event Handler Substitutions](https://awesome-repositories.com/f/testing-quality-assurance/event-handler-testing/event-handler-substitutions.md) — Provides mechanisms to temporarily substitute event handlers during dispatch cascades to facilitate testing and instrumentation. ([source](http://day8.github.io/re-frame/api-re-frame.tooling/))
- [Event Stream Recording](https://awesome-repositories.com/f/testing-quality-assurance/event-stream-recording.md) — Streams finished event traces to registered callbacks for auditing and debugging purposes. ([source](http://day8.github.io/re-frame/api-re-frame.tooling/))
- [Business Logic Isolation](https://awesome-repositories.com/f/testing-quality-assurance/general-testing-utilities/test-isolation/logic-isolation-utilities/business-logic-isolation.md) — Verifies state-transition and computation functions by executing them as standalone units with mock inputs. ([source](http://day8.github.io/re-frame/Testing/))
- [Functional Logic Testing](https://awesome-repositories.com/f/testing-quality-assurance/javascript-application-testing/functional-logic-testing.md) — Verifies component behavior and event processing using specialized testing utilities and frameworks. ([source](http://day8.github.io/re-frame/External-Resources/))
- [Cross-Platform Test Execution](https://awesome-repositories.com/f/testing-quality-assurance/testing-infrastructure-management/cross-platform-test-execution.md) — Runs the same codebase on both the Java Virtual Machine and JavaScript environments to ensure consistent behavior. ([source](http://day8.github.io/re-frame/FAQs/Why-CLJC/))
- [Unit Testing Frameworks](https://awesome-repositories.com/f/testing-quality-assurance/unit-testing-frameworks.md) — Isolates event and subscription logic into named functions to verify transformations independently of framework registration. ([source](http://day8.github.io/re-frame/Testing/))

### User Interface & Experience

- [Application State Management](https://awesome-repositories.com/f/user-interface-experience/application-state-management.md) — Maintains a centralized state store that drives reactive user interface updates through a cyclical event loop. ([source](http://day8.github.io/re-frame/browser-dynamics/))
- [Component Update Optimizations](https://awesome-repositories.com/f/user-interface-experience/component-update-optimizations.md) — Layers and de-duplicates data subscriptions so components only re-render when their specific slice of state changes. ([source](http://day8.github.io/re-frame/FAQs/DoINeedReFrame/))
- [Event-Driven State Managers](https://awesome-repositories.com/f/user-interface-experience/event-driven-state-managers.md) — Represents user intent and system actions as a sequence of data-driven events that act as instructions for the application. ([source](http://day8.github.io/re-frame/data-oriented-design/))
- [State-Driven UI Rendering](https://awesome-repositories.com/f/user-interface-experience/event-driven-state-managers/event-driven-state-synchronizers/ui-state-recomposition/state-driven-ui-rendering.md) — Binds view components to state queries so the user interface updates automatically when data changes. ([source](http://day8.github.io/re-frame/dominoes-live/))
- [State-to-UI Mapping](https://awesome-repositories.com/f/user-interface-experience/event-driven-state-managers/event-driven-state-synchronizers/ui-state-recomposition/state-to-ui-mapping.md) — Syncs interface elements with application data and event handlers to ensure automatic view updates. ([source](http://day8.github.io/re-frame/reusable-components/))
- [Event Handlers](https://awesome-repositories.com/f/user-interface-experience/event-handlers.md) — Defines how the application responds to specific events by associating an ID with a handler function. ([source](http://day8.github.io/re-frame/api-re-frame.core/))
- [Coeffect Handler Registries](https://awesome-repositories.com/f/user-interface-experience/event-handlers/event-handler-instance-retrievers/coeffect-handler-registries.md) — Defines providers for external resources or data needed by event handlers, ensuring handlers remain pure and testable. ([source](http://day8.github.io/re-frame/api-re-frame.core-instrumented/))
- [Event Handling Systems](https://awesome-repositories.com/f/user-interface-experience/form-and-input-management/interaction-and-event-handling/event-handling-architectures/event-handling-systems.md) — Registers functions to process events, compute state transitions, and return declarative descriptions of side effects. ([source](http://day8.github.io/re-frame/dominoes-30k/))
- [Application Event Dispatching](https://awesome-repositories.com/f/user-interface-experience/form-and-input-management/interaction-and-event-handling/event-handling-architectures/input-event-dispatchers/application-event-dispatching.md) — Dispatches one or more events to be handled by the system in a first-in-first-out order. ([source](http://day8.github.io/re-frame/api-builtin-effects/))
- [Global State Managers](https://awesome-repositories.com/f/user-interface-experience/global-state-managers.md) — Stores all application state in a single location and updates it through transactional commits to ensure consistency. ([source](http://day8.github.io/re-frame/FAQs/DoINeedReFrame/))
- [Reactive UI Updates](https://awesome-repositories.com/f/user-interface-experience/reactive-ui-updates.md) — Automatically re-computes and updates the user interface in response to state changes. ([source](http://day8.github.io/re-frame/App-Structure/))
- [Reactive User Interfaces](https://awesome-repositories.com/f/user-interface-experience/reactive-user-interfaces.md) — Transforms application state into visual components using functional templates that reactively update when data dependencies change. ([source](http://day8.github.io/re-frame/dominoes-live/))
- [Reactive Rendering Engines](https://awesome-repositories.com/f/user-interface-experience/signal-based-reactivity/reactive-rendering-engines.md) — Transforms queried state into interface components that update automatically whenever their subscribed data changes. ([source](http://day8.github.io/re-frame/dominoes-live/))
- [UI State Synchronization](https://awesome-repositories.com/f/user-interface-experience/ui-state-synchronization.md) — Binds components to data subscriptions so the interface automatically refreshes on state change. ([source](http://day8.github.io/re-frame/FAQs/why-didnt-my-component-update/))
- [User Event Handlers](https://awesome-repositories.com/f/user-interface-experience/user-event-handlers.md) — Dispatches events from user actions to trigger a sequence of state transitions and side effects. ([source](http://day8.github.io/re-frame/a-loop/))
- [Application Mount Points](https://awesome-repositories.com/f/user-interface-experience/application-mount-points.md) — Initializes the application by setting the starting state and attaching the primary user interface to a DOM element. ([source](http://day8.github.io/re-frame/dominoes-live/))
- [Application State Querying](https://awesome-repositories.com/f/user-interface-experience/application-state-managers/application-state-querying.md) — Retrieves processed data from the application state using customizable query formats. ([source](http://day8.github.io/re-frame/api-intro/))
- [Background Processing](https://awesome-repositories.com/f/user-interface-experience/background-processing.md) — Offloads heavy computations to background threads to maintain interface responsiveness. ([source](http://day8.github.io/re-frame/External-Resources/))
- [Pure Components](https://awesome-repositories.com/f/user-interface-experience/component-utilities/ui-frameworks/rendering-models/composition-rendering-patterns/component-patterns/pure-components.md) — Implements components as pure functions that produce consistent output for given inputs without side effects. ([source](http://day8.github.io/re-frame/Testing/))
- [Lifecycle-Aware Calculation Toggles](https://awesome-repositories.com/f/user-interface-experience/coordinate-based-position-calculators/transform-calculators/lifecycle-aware-calculation-toggles.md) — Runs or pauses derived calculations based on a truthy condition to prevent expensive operations when data is not needed. ([source](http://day8.github.io/re-frame/Flows/))
- [Declarative Component Data Structures](https://awesome-repositories.com/f/user-interface-experience/data-display-components/declarative-component-data-structures.md) — Represents user interfaces as declarative data structures that reactively update based on state changes. ([source](http://day8.github.io/re-frame/flow-mechanics/))
- [Component Output Verifiers](https://awesome-repositories.com/f/user-interface-experience/data-view-customizers/data-view-renderers/component-output-verifiers.md) — Checks that UI components render the correct data structures by passing mock values. ([source](http://day8.github.io/re-frame/Testing/))
- [Delayed Event Scheduling](https://awesome-repositories.com/f/user-interface-experience/delayed-event-scheduling.md) — Triggers specific events after a defined millisecond delay to manage asynchronous timing. ([source](http://day8.github.io/re-frame/api-builtin-effects/))
- [Event Handler Removals](https://awesome-repositories.com/f/user-interface-experience/event-handlers/event-handler-removals.md) — Deletes a previously registered event handler from the system to stop it from responding to specific events. ([source](http://day8.github.io/re-frame/api-builtin-effects/))
- [Stable Event Handler Optimizers](https://awesome-repositories.com/f/user-interface-experience/event-handlers/stable-event-handler-optimizers.md) — Prevents unnecessary re-renders by ensuring event handler functions remain referentially stable. ([source](http://day8.github.io/re-frame/on-stable-dom-handlers/))
- [Form and Input Management](https://awesome-repositories.com/f/user-interface-experience/form-and-input-management.md) — Manages complex user input fields, validation, and form state transitions within the application. ([source](http://day8.github.io/re-frame/External-Resources/))
- [Form Handling](https://awesome-repositories.com/f/user-interface-experience/form-and-input-management/form-handling.md) — Manages complex form state, validation, and submission logic within reactive data flows. ([source](http://day8.github.io/re-frame/External-Resources/))
- [Event Processing Error Handlers](https://awesome-repositories.com/f/user-interface-experience/form-and-input-management/interaction-and-event-handling/event-handling-architectures/event-handling/event-processing-error-handlers.md) — Captures and responds to exceptions raised during event handler execution with access to event context. ([source](http://day8.github.io/re-frame/api-re-frame.core/))
- [Event Processing Interceptors](https://awesome-repositories.com/f/user-interface-experience/form-and-input-management/interaction-and-event-handling/event-handling-architectures/event-handling/event-processing-error-handlers/event-processing-interceptors.md) — Wraps event handlers with functions that can modify input data, narrow the database scope, or execute post-processing logic. ([source](http://day8.github.io/re-frame/api-re-frame.core/))
- [Form Input Handling](https://awesome-repositories.com/f/user-interface-experience/form-input-handling.md) — Provides mechanisms for tracking and synchronizing user input forms with application state. ([source](http://day8.github.io/re-frame/External-Resources/))
- [Imperative UI Dispatchers](https://awesome-repositories.com/f/user-interface-experience/imperative-ui-dispatchers.md) — Selects and renders specific interface elements based on application state using conditional logic to ensure consistent reactivity. ([source](http://day8.github.io/re-frame/FAQs/why-didnt-my-component-update/))
- [Declarative Interface Definitions](https://awesome-repositories.com/f/user-interface-experience/interactive-interface-builders/declarative-builder-interfaces/declarative-interface-definitions.md) — Uses data-based domain-specific languages to describe application state, effects, and user interfaces. ([source](http://day8.github.io/re-frame/on-dynamics/))
- [State Flow Visualizers](https://awesome-repositories.com/f/user-interface-experience/interactive-ui-components/component-interaction-management/state-flow-visualizers.md) — Provides interactive displays of component trees and state flow to trace data relationships and debug application logic. ([source](http://day8.github.io/re-frame/External-Resources/))
- [Reusable UI Components](https://awesome-repositories.com/f/user-interface-experience/reusable-ui-components.md) — Creates reusable interface pieces that accept data and callbacks as arguments to remain independent of business logic. ([source](http://day8.github.io/re-frame/reusable-components/))
- [State Subscription Signals](https://awesome-repositories.com/f/user-interface-experience/state-driven-ui-controllers/reactive-state-syncing/state-subscription-signals.md) — Returns a reactive signal that streams values from the application state, automatically updating components. ([source](http://day8.github.io/re-frame/Loading-Initial-Data/))
- [Parameterized State Views](https://awesome-repositories.com/f/user-interface-experience/state-driven-view-functions/parameterized-state-views.md) — Passes maps or vectors to subscription handlers to retrieve filtered or specific slices of application state. ([source](http://day8.github.io/re-frame/FAQs/alpha/))
- [UI Components](https://awesome-repositories.com/f/user-interface-experience/ui-components.md) — Builds modular interface elements that accept data and event callbacks as arguments for consistent reuse. ([source](http://day8.github.io/re-frame/reusable-components/))
- [Synchronous Update Flushers](https://awesome-repositories.com/f/user-interface-experience/update-batching/synchronous-update-flushers.md) — Forces immediate rendering of interface updates to ensure the DOM is synchronized before executing subsequent tasks. ([source](http://day8.github.io/re-frame/Solve-the-CPU-hog-problem/))
- [View Coordination Systems](https://awesome-repositories.com/f/user-interface-experience/view-coordination-systems.md) — Coordinates state synchronization and navigation across multiple application views. ([source](http://day8.github.io/re-frame/App-Structure/))
- [State-Based View Injection](https://awesome-repositories.com/f/user-interface-experience/view-hierarchy-injections/state-based-view-injection.md) — Tracks active interface components in the global state to update displayed panels based on navigation. ([source](http://day8.github.io/re-frame/App-Structure/))
- [Navigation State Tracking](https://awesome-repositories.com/f/user-interface-experience/viewport-navigation-controls/navigation-state-tracking.md) — Tracks active application state to conditionally render interface panels based on user navigation. ([source](http://day8.github.io/re-frame/App-Structure/))
- [Virtual DOM Rendering Engines](https://awesome-repositories.com/f/user-interface-experience/virtual-dom-rendering-engines.md) — Provides a declarative UI layer that optimizes view updates via minimal change calculation. ([source](http://day8.github.io/re-frame/flow-mechanics/))

### Artificial Intelligence & ML

- [CQRS Patterns](https://awesome-repositories.com/f/artificial-intelligence-ml/ai-powered-data-assistants/read-only-database-querying/read-write-node-separations/cqrs-patterns.md) — Separates read operations via subscriptions and write operations via event handlers to optimize performance. ([source](http://day8.github.io/re-frame/FAQs/FullStackReframe/))
- [Dispatch Provenance Tracings](https://awesome-repositories.com/f/artificial-intelligence-ml/memory-provenance-tracking/event-sourced-provenance/dispatch-provenance-tracings.md) — Attaches source metadata to event and subscription definitions to track call-site provenance without stack traces. ([source](http://day8.github.io/re-frame/Debugging/))
- [Instruction-Based Virtual Machines](https://awesome-repositories.com/f/artificial-intelligence-ml/model-as-a-service-platforms/instruction-based-virtual-machines.md) — Models application intent as data structures that act as a domain-specific language, executed by registered handlers. ([source](http://day8.github.io/re-frame/data-oriented-design/))

### DevOps & Infrastructure

- [External Dependency Injections](https://awesome-repositories.com/f/devops-infrastructure/dependency-management/external-dependency-managers/external-dependency-injections.md) — Provides required external data or resources to event handlers as coeffects to maintain function purity and testability. ([source](http://day8.github.io/re-frame/EffectfulHandlers/))
- [Event Processing Schedulers](https://awesome-repositories.com/f/devops-infrastructure/event-and-schedule-routing/scheduler-lifecycle-events/event-processing-schedulers.md) — Queues events for asynchronous execution to ensure they are handled in a predictable order. ([source](http://day8.github.io/re-frame/FAQs/When-Does-Dispatch-Happen/))
- [Background Process Offloading](https://awesome-repositories.com/f/devops-infrastructure/workflow-run-management/asynchronous-run-launches/background-process-offloading.md) — Offloads heavy computations to background processes to keep the main user interface responsive. ([source](http://day8.github.io/re-frame/External-Resources/))

### Education & Learning Resources

- [Dependent Flow Composition](https://awesome-repositories.com/f/education-learning-resources/skill-advancement-resources/progressive-skill-sequences/dependency-chains/dependent-flow-composition.md) — Composes data transformation flows into dependency graphs to ensure correct execution order. ([source](http://day8.github.io/re-frame/Flows/))

### Mobile Development

- [App Navigation Frameworks](https://awesome-repositories.com/f/mobile-development/app-navigation-frameworks.md) — Tracks active views in the global state to switch between panels or screens based on user interaction. ([source](http://day8.github.io/re-frame/App-Structure/))
- [Native Mobile App Development](https://awesome-repositories.com/f/mobile-development/native-mobile-app-development.md) — Builds native mobile applications using the same functional state management patterns as web interfaces. ([source](http://day8.github.io/re-frame/External-Resources/))
- [React Native Applications](https://awesome-repositories.com/f/mobile-development/react-native-applications.md) — Targets mobile platforms using React Native to create native user interfaces with shared functional logic. ([source](http://day8.github.io/re-frame/External-Resources/))

### Networking & Communication

- [HTTP Request Execution](https://awesome-repositories.com/f/networking-communication/http-request-execution.md) — Executes standard HTTP network requests to retrieve or transmit data to remote servers. ([source](http://day8.github.io/re-frame/External-Resources/))
- [Procedure Execution Interception](https://awesome-repositories.com/f/networking-communication/remote-procedure-execution/procedure-execution-interception.md) — Provides hooks into event processing to execute custom logic before or after handlers for cross-cutting concerns. ([source](http://day8.github.io/re-frame/api-intro/))

### Security & Cryptography

- [State Access Restrictions](https://awesome-repositories.com/f/security-cryptography/domain-access-restrictions/request-access-restrictions/resource-access-restrictions/action-based-access-restrictions/conditional-access-restrictions/state-access-restrictions.md) — Restricts event handler access to specific sub-paths of the application state to ensure data isolation. ([source](http://day8.github.io/re-frame/api-re-frame.core/))

### System Administration & Monitoring

- [Subscription Handler Registries](https://awesome-repositories.com/f/system-administration-monitoring/alert-notification-systems/subscription-management/subscription-callback-handlers/subscription-handler-registries.md) — Defines logic to compute and return specific views of the application state for consumption by the UI. ([source](http://day8.github.io/re-frame/api-intro/))
- [Application Tracing Libraries](https://awesome-repositories.com/f/system-administration-monitoring/application-event-loggers/application-tracing-libraries.md) — Captures structured event streams and subscription records to diagnose state transitions and performance. ([source](http://day8.github.io/re-frame/api-intro/))
- [Frontend Performance Monitoring](https://awesome-repositories.com/f/system-administration-monitoring/application-performance-monitoring/application-performance-monitoring/frontend-performance-monitoring.md) — Tracks internal state changes, subscription execution, and view rendering cycles to identify performance bottlenecks. ([source](http://day8.github.io/re-frame/Performance-Problems/))
- [Diagnostic Monitors](https://awesome-repositories.com/f/system-administration-monitoring/diagnostic-monitors.md) — Exposes live subscription queries and event traces to external tooling for real-time performance analysis. ([source](http://day8.github.io/re-frame/api-intro/))
- [Framework Execution Path Tracings](https://awesome-repositories.com/f/system-administration-monitoring/execution-tracing/framework-execution-path-tracings.md) — Traces the internal execution path of framework operations to understand update processing and performance. ([source](http://day8.github.io/re-frame/api-re-frame.core-instrumented/))
- [Execution Tracing](https://awesome-repositories.com/f/system-administration-monitoring/monitoring-and-observability/execution-tracing-analysis/execution-tracing.md) — Registers callbacks to receive batches of finished execution traces and epoch records. ([source](http://day8.github.io/re-frame/api-re-frame.core-instrumented/))
- [Observability Instrumentation](https://awesome-repositories.com/f/system-administration-monitoring/observability-instrumentation.md) — Provides diagnostic hooks to trace event execution, validate schemas, and inspect state changes during development. ([source](https://cdn.jsdelivr.net/gh/day8/re-frame@master/README.md))
- [Trace State Persistence](https://awesome-repositories.com/f/system-administration-monitoring/observability-tracing/trace-state-persistence.md) — Records application state and event sequences to enable replay-based debugging and error reproduction. ([source](http://day8.github.io/re-frame/Performance-Problems/))
- [Interceptor-Based State Monitors](https://awesome-repositories.com/f/system-administration-monitoring/resource-monitoring/resource-change-monitors/state-change-monitoring/interceptor-based-state-monitors.md) — Uses interceptors to watch specific state paths and run computations to update other paths whenever values change. ([source](http://day8.github.io/re-frame/api-re-frame.core/))
- [State Transition Logging](https://awesome-repositories.com/f/system-administration-monitoring/resource-monitoring/resource-change-monitors/state-change-monitoring/state-transition-logging.md) — Compares the application database before and after an event handler runs and logs differences. ([source](http://day8.github.io/re-frame/Debugging/))