Open-source alternatives to Gops

This project is a comprehensive technical guide and diagnostic manual for analyzing memory, performance, and asynchronous behavior within Node.js applications. It provides detailed methods for asynchronous tracing, memory diagnostics, and performance analysis to resolve runtime errors and execution bottlenecks. The resource distinguishes itself by covering advanced diagnostic workflows, including the use of flame graphs for CPU profiling, the capture and comparison of heap snapshots for memory leak detection, and the mapping of asynchronous call stacks. It also provides technical guidance on

Pixie is an open-source observability platform for Kubernetes that uses eBPF to automatically capture telemetry data from clusters without requiring any manual instrumentation or code changes. It functions as an eBPF telemetry collector, a continuous application profiler, a network traffic analyzer, and a scriptable telemetry query engine, all within a single Kubernetes-native tool. The platform distinguishes itself through several integrated capabilities. It continuously samples stack traces from compiled-language code to identify CPU performance bottlenecks, visualizing the results as inter

This project is a Chinese translation of a comprehensive guide to the Go programming language. It serves as a localized educational resource and technical manual designed to provide guidance on language syntax, design, and software development. The resource covers a broad range of Go language education, including the implementation of programming patterns and system design. It includes translated lessons and examples that focus on core language features such as concurrency and the use of interfaces. The content spans various capability areas, including language fundamentals, data modeling, r

Snowflake is a high-concurrency RPC framework and distributed ID generation service. It provides the infrastructure to create unique, time-ordered identifiers across a network of servers and facilitates the development of network services designed to handle massive volumes of simultaneous requests. The system separates low-level transport logic from application behavior, allowing for the implementation of custom RPC protocols. It includes a distributed request tracing tool to visualize execution flow across network boundaries and a server lifecycle management interface to adjust logging level

Inspektor Gadget is an eBPF observability toolset and program framework designed for tracing Linux systems and debugging Kubernetes nodes. It provides a suite of tools to collect kernel-level telemetry and export system metrics via the OpenTelemetry standard. The project distinguishes itself by packaging inspection tools as OCI-compliant container images, allowing for standardized distribution and deployment across clusters and hosts. It employs a modular data processing pipeline that utilizes WebAssembly modules to transform and filter telemetry, and leverages Compile Once Run Everywhere for

pprof is a tool for visualizing and analyzing performance profiling data. It converts sampled call stacks into a directed graph rendered as an SVG, enabling visual identification of execution hotspots. The tool also parses Linux perf.data files, converting them into an internal profile representation for further analysis. Beyond visualization, pprof provides a command-line REPL for interactive exploration of profiling data, allowing users to filter, refine, and query performance information on the fly. It generates sorted text reports that highlight the most resource-intensive call stacks, an

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

brpc is a high-performance C++ RPC framework and network programming library designed for building distributed systems. It functions as a multi-protocol RPC server capable of hosting and detecting multiple communication protocols, including gRPC, Thrift, HTTP, Redis, and Memcached, on a single TCP port. The project distinguishes itself through high-throughput data transport and memory efficiency, utilizing RDMA-based transport to bypass the kernel TCP stack and zero-copy memory management to eliminate data duplication. It also implements the Raft algorithm for consensus-based state replicatio

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

This project is a comprehensive, curated directory of static analysis, linting, and security scanning utilities. It serves as a central resource for developers to discover, compare, and select tools based on specific programming languages, licensing models, and integration requirements. The directory distinguishes itself by providing deep metadata for each listed utility, including community-driven popularity rankings, maintenance status, and deployment methods. By aggregating these tools into a single searchable index, it enables teams to identify solutions for enforcing coding standards, ma

Visualise Go runtime metrics in real time

Command line monitoring for goroutines

nghttp2 is a suite of low-level C libraries and tools designed for implementing the HTTP/2 protocol. It provides a memory-efficient implementation of the protocol's core logic, including framing, stream multiplexing, and flow control. The project includes a dedicated library for HPACK header compression and decompression to reduce network bandwidth. It also provides a toolset for analyzing network traffic and benchmarking server performance, including throughput and latency measurements. Its broader capabilities cover protocol implementation and traffic management, including ALPN connection

Janet is a Lisp-based dynamic programming language featuring a register-based bytecode virtual machine and an embeddable scripting engine. It functions as a fiber-based concurrency runtime and includes a parsing engine based on Parsing Expression Grammars. The project is distinguished by its ability to be integrated into C or C++ applications via a minimal header interface. It utilizes a Lisp-style macro system for compile-time code transformation and employs prototype-based table inheritance for object-oriented behavior. The runtime covers a broad set of capabilities, including asynchronous

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

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

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

Beszel is a self-hosted server monitoring platform designed to track real-time performance metrics across multiple host systems and containerized environments. It functions as a centralized dashboard that aggregates data on processor, memory, disk, and network usage, providing visibility into both host-level infrastructure and individual container workloads. The system utilizes lightweight agents to collect performance data, which is then streamed to a central hub and stored in a local relational database. It distinguishes itself through a real-time analytics engine that uses persistent bidir

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

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

MangoHud is a Linux hardware monitor and performance overlay that displays real-time metrics and frame rates. It functions as a graphics API hook, intercepting Vulkan and OpenGL pipelines to render performance data directly onto the graphics buffer. The project serves as both a real-time monitor for CPU and GPU utilization, temperatures, and power draw, and a frametime data logger that records execution speed to disk for later benchmarking and analysis. Users can modify the overlay display, visual styles, and active metrics through configuration files, environment variables, or predefined pe

This project is a collection of educational resources and technical guides focused on Go performance optimization. It provides instruction on improving execution speed and reducing memory usage through code and architectural refinements. The guides cover advanced strategies for low-level programming, including the use of assembly for SIMD instructions and unsafe pointers for direct memory manipulation. It also details concurrency optimization techniques such as lock sharding and cache-line padding to reduce contention and improve hardware utilization. The material encompasses broad capabilit

This project is a profiling utility written in Rust that captures, transforms, and visualizes function call stacks to identify system performance bottlenecks. It functions as a sampling profiler wrapper that converts raw profiling data into interactive flamegraphs, which are hierarchical maps of resource consumption. The tool provides specialized integration with the Rust build system to profile binaries and performance benchmarks. It also allows for custom profiling configurations, enabling users to override default system profiling tools or recording flags to control how data is collected.

Booster is an Android app build optimizer and bytecode manipulator designed to reduce binary size, fix system-level crashes, and improve application performance. It functions as an extensible build process plugin that modifies compiled class files and build artifacts to inject stability fixes and optimizations without altering the original source code. The project differentiates itself through low-level bytecode manipulation to patch OS-level bugs and manage thread pools during the compilation phase. It also provides a performance profiling toolkit to identify main-thread blocking operations

backward-cpp is a C++ stack trace library and debugging utility designed to capture, resolve, and print detailed execution traces and crash reports. It functions as a crash reporter and call stack printer that translates raw memory addresses into human-readable function names, filenames, and line numbers. The project provides automated crash reporting by registering system handlers for fatal errors, such as segmentation faults, to automatically generate execution traces upon program failure. It distinguishes itself by extracting source file fragments from disk to display specific lines of cod

DeviceKit is a hardware library for iOS that provides a value-type replacement for device specifications and system state metrics. It serves as a framework for detecting device identity, hardware capabilities, display metrics, and real-time system state indicators. The library includes tools for identifying specific device models, families, and simulator status to implement hardware-specific optimizations. It also provides a detector for physical components, such as biometric sensors and stylus support, to toggle interface features. Additional capabilities cover display metrics analysis for

sysbench is a database and system benchmark tool used to measure the throughput and latency of database systems and hardware components. It functions as a multi-threaded workload generator and hardware performance profiler designed to determine how systems perform under heavy load. The project serves as a scriptable benchmark engine, allowing for the definition of custom performance scenarios through scripts. It simulates real-world traffic patterns by generating random data based on mathematical probability distributions, such as Zipfian, Gaussian, or Pareto. Capabilities cover database per