Open-source alternatives to Reactime

why-did-you-update is a React development tool and performance profiler designed to identify unnecessary component re-renders. It functions as a render debugger that logs the specific prop and state changes triggering updates to the developer console. The utility focuses on React performance optimization by detecting wasteful update cycles. It provides diagnostic logging to highlight why a component updated, helping to reduce redundant user interface cycles. The tool covers frontend performance profiling through the use of higher-order component wrappers, state snapshot comparisons, and refe

This project is a performance debugger and render profiler for React and React Native applications. It serves as a diagnostic utility to detect avoidable render cycles and identify the specific props, state, or hook changes that trigger component updates. The tool distinguishes itself by tracking the execution of both custom and third-party hooks to determine if their return values are causing unnecessary renders. It employs deep equality checks to notify developers when a component re-renders despite its props and state remaining functionally identical. Broad capabilities include frontend b

Reactide is the first dedicated IDE for React web application development.

React DevTools is a set of web browser developer tools integrated into Chrome and Firefox. It functions as a component inspector and UI debugger designed to visualize the component hierarchy and analyze the runtime behavior of React applications. The project includes a performance profiler used to detect unnecessary component re-renders and improve rendering efficiency. It also provides utilities for mapping virtual component trees to the physical DOM and linking rendered UI elements directly to their corresponding source code files and line numbers. The toolset covers component hierarchy vi

MobX State Tree is a structured, tree-based state management library for JavaScript applications that combines typed model definitions with reactive snapshots and patch-based change tracking. It provides a reactive state container with runtime and compile-time type safety, where application state is defined as a tree of typed models with collocated actions, computed views, and lifecycle hooks for predictable state mutations. The library is built around an action-centric mutation model that encapsulates all state changes within named functions that directly modify the tree, supported by genera

re-frame is a functional framework for building single-page applications in ClojureScript. It provides a centralized, immutable database that serves as the single source of truth for the entire application state, enforcing a strict unidirectional data flow where events trigger state transitions and subsequent view updates. The framework distinguishes itself through a reactive signal graph and an interceptor-based middleware pipeline. By treating application logic as a sequence of data-driven events and declarative side effects, it decouples business logic from the view layer. This architectur

Redux is a global state management library and predictable state container for JavaScript applications. It implements a store pattern that maintains the entire application state as a single source of truth, ensuring consistent behavior across different components and environments. The library relies on a unidirectional data flow where state updates follow a strict one-way cycle. This is achieved through a system of discrete actions, pure-function reducers, and a centralized store to ensure that state transitions remain predictable and traceable. The framework includes capabilities for monito

Jotai is a state management library for React applications that utilizes an atomic model to handle data. It organizes application state into small, independent units called atoms, which automatically track dependencies and trigger granular updates to components. By building state through these composable primitives, the library ensures that only the necessary parts of an application re-render when data changes. The library distinguishes itself through its flexible approach to state composition and asynchronous data handling. It integrates promises directly into the state model, allowing devel

Easy Profiler is a performance profiling library for C++ applications designed to measure execution duration and identify bottlenecks. It provides a framework for instrumenting code blocks to track performance metrics, allowing for the analysis of thread activity and system behavior through detailed timeline visualization. The library distinguishes itself by utilizing scope-based instrumentation to automatically track code lifecycles, minimizing manual overhead. It employs thread-local buffering and asynchronous data flushing to reduce synchronization contention, ensuring that performance dat

This project is a cross-platform development framework that enables the execution of React Native applications as native desktop software. By utilizing the Qt toolkit, it maps mobile-oriented interface components to native desktop widgets, allowing developers to deploy a single codebase across Linux, macOS, and Windows. The framework functions as a bridge between JavaScript-based application logic and native system interfaces. It includes a native module bridge that exposes system-level hardware and platform capabilities to the JavaScript runtime, facilitating the integration of custom C++ or

Pyroscope is a continuous profiling platform designed to collect, store, and visualize application performance data. It functions as an application performance management suite that tracks historical resource usage to identify bottlenecks and detect performance regressions over time. The platform distinguishes itself through its use of kernel-level instrumentation and dynamic runtime hooks, which allow for performance monitoring without requiring manual code modifications or application restarts. It employs a sidecar agent architecture to offload telemetry processing, utilizing delta-encoded

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

This project is a reactive state management library designed for handling complex form data and validation logic. It utilizes observable-based patterns to synchronize user interface components with underlying data models, ensuring that form states remain consistent throughout an application. The library provides a structured approach to managing form initialization, field tracking, and lifecycle events. The library distinguishes itself through its support for deeply nested data structures and hierarchical composition, allowing for recursive validation and dynamic updates within complex object

This is a personal portfolio website that uses scroll position to drive complex SVG scene animations, creating an interactive storytelling experience. The project is built around a scroll-synchronised animation controller that maps user scrolling to a timeline of interpolated state changes across a directed graph of visual elements, enabling fluid scene transitions. The site features a real-time animation state debugger that overlays a live HUD showing timing, active elements, and scene breakdown, with console commands for scene jumping and state export. It also includes a gradient-preserving

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

Samply is a cross-platform CPU sampling profiler and performance analysis utility. It consists of a command-line tool for recording process stack traces at regular intervals and a visual interface for analyzing the resulting execution data. The system includes a debug symbol resolver that maps raw memory addresses to human-readable function names using local or remote symbol information. It transforms recorded execution data into flame graphs and timelines to pinpoint function-level hotspots. The tool provides capabilities for CPU execution recording, stack unwinding, and symbol resolution a

nativescript-vue is a framework for building native iOS and Android applications using Vue components and a reactive state system. It functions as a cross-platform mobile UI library that renders platform-specific views instead of web views, utilizing a native mobile application bridge to connect Vue logic to NativeScript APIs for direct access to mobile hardware and OS features. The framework employs a reactive mobile component system to create high-performance screens and dynamic lists with automatic state updates. This architecture allows for the development of native mobile applications fr

Async-profiler is a sampling profiler for Java applications that tracks CPU time and stack traces across execution frames to identify performance bottlenecks. It is designed to capture profiling data without introducing timing bias. The project provides capabilities for JVM memory analysis to locate native and heap allocation hotspots and memory leaks. It also includes system contention analysis to identify resource bottlenecks through the tracking of contended locks and hardware performance counters. The tool converts raw profiling data into visual performance reports, including interactive

This project is a state management framework for Angular applications that provides a predictable state container. It implements a Redux-style architecture using a centralized store, managing global and local application data through an observable-based data flow of actions and reducers. The framework includes a specialized entity management tool for organizing and synchronizing server-side data collections within client-side stores. It also provides a reactive store system that integrates state updates with Angular signals for change detection and includes debugging mechanisms for time-trave

This project is a performance analysis tool for Ruby applications using the Rack interface. It monitors request execution times and resource usage, serving as a profiler for web applications to measure latency and identify bottlenecks. The tool provides specific analyzers for database query performance, memory allocations, and garbage collection statistics. It generates call stack flamegraphs to visualize time distribution across methods and renders speed badges and timing metrics directly onto HTML pages. The system covers broader performance profiling capabilities including custom code blo

Optimism is an Ethereum optimistic rollup stack designed to increase transaction throughput by processing transactions on a secondary layer and settling the state on the Ethereum mainnet. It functions as a scaling framework that utilizes a rollup sequencer to order transactions, produce blocks, and submit batched data to the primary blockchain. The system features a fraud proof system that uses on-chain instruction emulation to resolve disputes and verify the correctness of state transitions. It includes a dedicated toolset for deploying and upgrading the smart contracts required to bootstrap

React Scan is a diagnostic utility and performance auditor designed to monitor the rendering lifecycle of components within user interfaces. It functions as an automated analysis tool that tracks component re-render cycles and execution timing to identify performance bottlenecks in real time. The tool distinguishes itself by providing visual feedback through a persistent overlay injected directly into the application. By instrumenting the reconciliation process and observing component state and props, it highlights specific rendering patterns that contribute to performance degradation. This

Tracy is a real-time performance profiling framework for C and C++ applications. It provides a software instrumentation library that captures high-resolution telemetry data, which is then visualized through a separate graphical interface to identify bottlenecks and resource allocation issues. The system utilizes a client-server architecture that enables remote profiling, allowing performance data to be captured on a target machine and analyzed on a workstation. It employs lock-free event logging and shared-memory ring buffers to minimize the overhead of data collection, ensuring that the main

Laravel Debugbar is a diagnostic utility and development toolbar designed for the Laravel framework. It functions as an application profiler that monitors runtime performance, memory usage, and database queries to assist in identifying bottlenecks during the development process. The tool integrates directly into the browser, providing a visual interface that displays request data, application state, and performance metrics. By utilizing a collector-based architecture, it aggregates information from various internal framework events and middleware, allowing developers to inspect the applicatio

DeepFlow is an eBPF observability platform that provides a suite for continuous profiling, distributed tracing, service dependency mapping, and unified telemetry storage. It functions as a monitoring system that collects metrics, traces, and profiles without requiring manual application instrumentation or modifications to source code. The platform distinguishes itself through the use of protocol-aware packet parsing to reconstruct request chains and automated service dependency mapping to visualize interactions between applications and infrastructure. It utilizes a telemetry data store design

Laravel Debugbar is a web-based debugging toolbar and application profiler for Laravel. It provides a visual interface to inspect database queries, logs, and performance metrics in real time to identify and resolve bugs during development. The tool features a database query monitor to capture SQL statements and timings, as well as a request inspector for analyzing route metadata, loaded views, and HTTP request data. It includes a profiler for measuring execution time and memory usage to identify bottlenecks in the request lifecycle. Its observability capabilities cover exception capture, app

React Native Debugger is a standalone developer application for inspecting and debugging JavaScript runtimes in mobile applications built with React Native. It provides a dedicated interface to monitor the runtime state, network requests, and console logs of a remote mobile environment. The tool integrates specialized inspectors for Redux state management and GraphQL client debugging, allowing for time-traveling state transitions and the analysis of queries, mutations, and local cache. It also features a component hierarchy viewer for visualizing and modifying UI properties in real time. Bro