Open-source alternatives to Node Clinic

Perfetto is a platform for system-level performance tracing and analysis on Linux and Android. It combines a high-throughput trace recorder, a SQL-based query engine, and a browser-based visualizer into a single toolchain. The platform covers CPU scheduling and call-stack profiling, native and Java heap memory allocation tracking, GPU and graphics events, and system-wide counters such as CPU frequency and power consumption. The architecture decouples trace recording from offline analysis, using a compact protobuf format for event encoding and columnar storage for efficient SQL queries. The we

Arthas is a Java diagnostic tool and runtime debugger designed for real-time troubleshooting of applications. It functions as a remote diagnostics agent that allows users to inspect the runtime state of a Java process, including its heap objects and classloader hierarchies, without requiring a process restart. The project distinguishes itself through advanced bytecode manipulation capabilities, enabling live class hotswapping and the modification of bytecode in running processes. It supports in-memory source compilation and runtime bytecode decompilation to verify and update logic instantly w

Async-profiler is a suite of performance tools designed for sampling Java runtimes, tracking memory allocations, and monitoring hardware counters. It functions as a low-overhead sampling profiler for Java applications, collecting stack traces and memory allocation data without safepoint bias. The project provides specialized utilities for generating interactive flame graphs to visualize execution hotspots in a web browser. It includes a hardware performance counter monitor to track low-level system events such as cache misses and page faults. The toolset covers several diagnostic domains, in

Isolated-vm is a library for creating secure, memory-isolated JavaScript execution environments within Node.js. It functions as a manager for the underlying engine, allowing developers to instantiate multiple independent execution contexts that share no memory or global state. This architecture is designed to support the execution of untrusted third-party code while preventing interference with the main application process. The project distinguishes itself by enforcing strict resource constraints, including memory limits and CPU execution timeouts, to ensure host system stability. It provides

Hotspot is a graphical user interface for analyzing and visualizing performance data captured by the Linux perf tool. It functions as a performance profiling visualizer and assembly-level profiler that maps performance costs to specific instructions synchronized with original source code. The project distinguishes itself through a remote symbol resolver that maps performance data from embedded targets to local host debug symbols and sysroots. It also includes a specialized off-CPU analysis tool designed to identify thread wait times and I/O blocks using kernel scheduler tracepoints. The tool

This project is a technical study and analysis guide focused on the internal architecture of Node.js. It provides an in-depth examination of the runtime, focusing on how the engine manages memory handles, executes asynchronous operations, and implements core module logic. The guide specifically analyzes the integration of native C++ classes and functions into JavaScript and documents the behavior of the libuv event loop. It includes detailed references for optimizing performance by identifying V8 compiler bailouts and profiling execution to improve resource efficiency. The material covers a

gperftools is a collection of specialized tools for profiling CPU usage, detecting memory errors, and providing high-performance memory allocation. It provides a memory profiling toolkit for C++ applications, including a sampling CPU profiler and a heap profiler for analyzing consumption patterns. The project includes a high-performance memory allocator designed as a multi-threaded replacement for standard allocation to reduce contention and improve execution speed. It further provides a memory debugger to identify illegal memory access and double frees. The toolkit covers broad diagnostic c

Memlab is an automated browser memory profiler and JavaScript memory leak analyzer. It provides a toolkit for detecting and analyzing memory leaks by inspecting and comparing heap snapshots to identify unbound object growth and detached DOM elements. The system distinguishes itself through an automated leak testing framework that executes end-to-end browser interaction sequences to programmatically isolate memory regressions. It utilizes heap snapshot diffing, retainer chain tracing, and heuristic-based filtering to determine why objects remain in memory and to map the shortest path from garb

vjtools is a comprehensive Java development toolset and runtime monitor designed for optimizing application performance and ensuring codebase consistency. It provides a suite of JVM diagnostics tools, a performance profiler, and a static analysis system for enforcing coding standards. The project distinguishes itself through specialized runtime observability, including the ability to attach to processes via process ID and inject dynamic probes to monitor method calls without restarting the system. It features container-aware resource detection that reads control group files to report actual C

go-torch is a profiling tool for capturing the execution state of Go programs and transforming raw binary data into visual representations of program performance. It functions as a flame graph profiler and performance visualization utility that identifies expensive code paths through the collection of CPU and memory stack traces. The tool features a network-capable remote process profiler that connects to endpoints to capture and export execution profiles from Go binaries. It utilizes stochastic profiling to synthesize execution data into call graphs, allowing for the identification of bottle

Ora is a terminal spinner library and Node.js CLI component used to integrate animated loading indicators and task-outcome symbols into JavaScript-based terminal applications. It functions as a progress visualizer that signals the status of command-line operations through animated sequences of characters. The library provides promise-based spinner wrapping, allowing animations to start and resolve automatically based on the outcome of asynchronous tasks. It replaces active animations with specific success, failure, warning, or info symbols to communicate the final result of a process. The to

vprof is a visual profiling tool for Python designed to identify execution bottlenecks and monitor memory consumption. It functions as a CPU and memory profiler that transforms performance data into interactive visualizations to analyze processor time and call stacks. The project distinguishes itself through a suite of visual diagnostics, including flame graphs for stack visualization and heatmaps that map execution frequency and duration directly onto source code. It also includes a remote performance monitor capable of capturing function-specific metrics from a running server and streaming

Halo is a Python library for rendering animated loading indicators and task completion symbols within terminal and notebook environments. It serves as a utility for providing visual feedback in command-line interfaces to signal that background processes are active. The library allows for the customization of loading spinner animations through the use of preset styles or custom character sequences and rotation intervals. It includes functionality to terminate active animations and replace them with specific status symbols and messages to indicate success, failure, or warnings. The project cov

BCC is an eBPF development toolkit and tracing framework used for monitoring and analyzing the Linux kernel. It functions as a performance analysis tool and debugging utility to capture system events, measure kernel latency, and provide network observability. The project distinguishes itself by providing a build system that integrates with LLVM to compile C-like code into BPF bytecode at runtime. It utilizes BPF Type Format data for relocations to maintain cross-kernel compatibility and extracts kernel headers to ensure the generated programs match the specific kernel version. The toolkit co

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

Fuite is a web application memory leak detector and browser heap snapshot analyzer. It functions as an automated interaction tester that monitors heap growth during repeated browser sequences to identify leaking DOM nodes and collections. The tool differentiates itself by executing scripted interaction loops to amplify memory growth, making leaks easier to detect. It captures and compares heap snapshots across different timestamps and exports detailed reports containing stack traces and the specific code locations where listeners were declared. The project covers browser automation and orche

nprogress is a lightweight JavaScript UI component and web progress bar library. It provides a minimalist DOM progress indicator used to track the state of asynchronous operations within a browser document. The library allows for the visualization of loading states through a thin progress bar and spinner. It supports progress state management, enabling the bar to be started, stopped, or marked as complete, with support for incremental progress tracking and percentage-based updates. Users can modify the visual style by overriding default CSS or replacing the markup template. The component als

Bistoury is a production diagnostics tool for Java applications that provides a distributed debugging console, a performance profiler, and a runtime bytecode manipulator. It enables real-time application debugging and production diagnostics by analyzing running Java applications through dynamic instrumentation and state inspection. The system distinguishes itself through a remote agent manager that coordinates diagnostic connections and a runtime bytecode manipulator capable of redefining classes in memory without requiring process restarts. It features a web interface for capturing heap dump

Scalene is a high-performance diagnostic utility designed to measure resource consumption during the execution of Python applications. It functions as a line-level monitor, providing granular insights that pinpoint the specific source code responsible for performance overhead. The tool distinguishes itself through statistical profiling that captures stack traces and resource usage without requiring manual instrumentation of the source code. It tracks CPU, GPU, and memory consumption by intercepting library-level calls and hardware driver commands, allowing for the analysis of both managed and

Memray is a memory profiler for Python that tracks heap allocations in both Python code and native C or C++ extensions. It captures memory events by hooking into the language runtime and traversing call stacks, providing a comprehensive view of how an application consumes memory. The tool is designed to minimize performance impact on the target application by using thread-local buffering and streaming data to an external process or file. The project distinguishes itself through its ability to monitor complex, multi-threaded systems and child processes in real-time. It provides diagnostic util

LearningNotes is a technical knowledge base and engineering study guide focused on Android framework internals, system architecture, and mobile performance optimization. It serves as a reference for analyzing the Android boot sequence, process bootstrapping, and system service initialization. The project provides detailed guides on mobile performance, including strategies for reducing memory footprints, identifying memory leaks, and optimizing image decoding. It further covers Android inter-process communication using AIDL and the Binder kernel driver, as well as software architecture manuals

The 1BRC (One Billion Row Challenge) is a Java performance benchmarking exercise that processes one billion temperature records from a text file to compute the minimum, mean, and maximum temperature per weather station. At its core, it is a large-scale data aggregation challenge designed to test how efficiently a Java program can parse and aggregate structured data from a plain text file, serving as both a programming exercise and a benchmark for Java performance optimization. The project distinguishes itself through a collection of performance-oriented architectural patterns for high-through

VizTracer is a Python runtime instrumentation system and execution profiler used to trace and visualize code execution. It functions as a multi-process performance analyzer and trace visualizer, providing an interactive timeline and flamegraph interface to identify performance bottlenecks and analyze call sequences. The project distinguishes itself by its ability to aggregate execution data from multiple threads, subprocesses, and asynchronous tasks into a single unified report. It also features live process instrumentation, allowing users to attach to and detach from running Python applicati

Bullet is an Active Record performance monitor and query profiler for Ruby on Rails applications. It serves as a diagnostic utility to identify inefficient database access patterns, flag redundant requests, and suggest eager loading strategies to improve response times. The tool specifically detects N+1 queries, missing counter caches, and unused eager loading. It monitors these patterns across both standard web requests and background jobs, identifying records that are fetched but never accessed to reduce memory usage and query overhead. Analysis is supported by a system that intercepts dat

This project is a technical reference and a collection of internal analysis notes focused on the Go language runtime and compiler. It provides a detailed breakdown of the language internals, covering memory management, garbage collection, and the execution model of the scheduler. The material distinguishes itself by providing deep dives into low-level system details, including a reference for Go assembly instructions, register usage, and system call interfacing. It specifically analyzes the internal implementation of concurrency primitives, such as the goroutine scheduling mechanism, channel

This project is a comprehensive educational resource and programming course covering C++ language semantics and features from C++03 through C++26. It provides structured tutorials and technical guides focused on modern C++ development. The material offers specialized instruction on template metaprogramming, including the use of type traits and compile-time computations. It features detailed guides on concurrency and parallelism for multi-core execution, as well as a reference for software design applying SOLID principles and RAII. Additionally, it covers build performance optimization to redu

JavaFamily is a curated set of learning paths and reference guides for backend engineering, distributed systems, and virtual machine internals. It provides a structured curriculum covering the Java language, operating system concepts, and network protocols. The project features detailed study guides for the Java virtual machine architecture, including memory management and garbage collection. It also includes a comprehensive reference for distributed systems, covering microservices, remote procedure call frameworks, and scalable system design. The collection covers a broad range of technical