Projects sharing features with Bytehound

Heaptrack is a heap memory profiler and diagnostic tool for applications running on Linux. It functions as a memory leak detector and performance analysis system that records heap allocations and stack traces to identify memory hotspots and consumption patterns. The project provides a graphical heap allocation visualizer for exploring memory usage through tree views and peak memory reports. It utilizes flame graphs and allocation charts to visualize memory hotspots and assist in the detection of leaks. The toolset includes capabilities for heap memory allocation tracing and the generation of

This project is a diagnostic tool and memory profiler designed to identify and track memory allocation patterns within native code layers. It functions as a native code debugging utility that monitors heap usage and resource lifecycle management to assist in the resolution of memory leaks and resource exhaustion issues. The tool utilizes hook-based allocation interception to maintain a real-time map of active memory blocks and employs shadow-stack call tracing to associate these blocks with specific code locations. By performing periodic reachability analysis and differential memory snapshott

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

MLeaksFinder is a diagnostic framework and profiling utility designed for the automatic detection of memory leaks and unfreed objects in iOS applications. It functions as a memory leak detector and profiling tool that identifies retain cycles and analyzes object lifecycles for both Swift and Objective-C code. The tool identifies circular dependencies by tracing reference chains and traversing object graphs, starting from a root view controller. It provides precise debugging data by capturing the allocation stacks of leaked objects to trace the origin of the memory leak. The framework include

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

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

This project is a Java runtime diagnostic tool and bytecode instrumentation framework. It provides a remote troubleshooting interface for inspecting live Java systems, analyzing execution traces, and monitoring method performance without requiring application restarts. The system distinguishes itself through its ability to modify Java classes at runtime to capture parameters and return values, combined with a JavaScript-based scripting engine for custom diagnostic logic. It further supports collaborative live debugging, allowing multiple users to connect to a single remote process simultaneou

Odin is a compiled, statically typed systems programming language designed for high-performance software development. It focuses on pragmatic low-level memory control, providing a toolset for manual memory management and precise control over hardware utilization. The language is distinguished by its flexible memory model, which includes custom allocators and precise data layout capabilities to optimize resource usage. It features a comprehensive foreign function interface for importing assembly files and linking with external libraries using configurable calling conventions. The type system

Memory Profiler is a diagnostic library for Ruby applications designed to monitor runtime memory consumption and object lifecycles. It provides tools to track object allocations and memory usage, enabling the identification of performance bottlenecks and potential memory leaks that affect software stability. The tool functions by observing memory behavior during program execution, allowing developers to distinguish between short-lived data and objects that persist beyond their intended lifecycle. It captures the execution context of allocations by walking the call stack, which helps attribute

c3c is the compiler for the C3 programming language, transforming source code into executable binaries, static libraries, or dynamic libraries using an LLVM backend. It implements a system based on result-based error handling, scoped memory pooling, and a semantic macro system. The compiler provides first-class support for hardware-backed SIMD vectors that map directly to processor instructions and enables runtime polymorphism through interface-based dynamic dispatch. The project covers a broad set of low-level capabilities, including manual and pooled memory management, inline assembly inte

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

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

Abseil is a common utility library for C++ that provides foundational building blocks for applications. It serves as a collection of optimized utility functions and data structures that augment the C++ standard library across different compiler versions. The library is distinguished by its high-performance containers, including SIMD-accelerated hash maps and sets for efficient key-value lookups. It also provides a comprehensive framework for computing absolute time points, durations, and timestamps across global time zones. The project covers a broad range of capability areas, including conc

Quickly find bottlenecks in Rust - one profiler for CPU, time, memory, and async code.

Enterprise-oriented Generic Proxy Solutions

Find code blocking your Tokio workers. eBPF-powered, no instrumentation.

Criterion is a statistics-driven microbenchmarking library and performance regression tool for Rust. It provides a framework for isolating and measuring small code segments, using statistical analysis to eliminate noise and ensure reliable, repeatable measurements of execution speed. The tool distinguishes itself through a performance visualization suite that generates HTML reports and graphs to track performance trends and throughput. It includes a system for comparing current execution times against stored baselines to identify and prevent performance drops. The library covers asynchronous

🐰 Bencher - Continuous Benchmarking

A stopwatch library for Rust. Used to time things.

An intrusive flamegraph profiling tool for rust.

Fast and simple benchmarking for Rust projects

Chartkick is a Ruby on Rails visualization library and JavaScript charting wrapper that provides a high-level interface for integrating interactive charts into web applications. It functions as a multi-engine charting adapter, wrapping various JavaScript charting libraries to provide a consistent API for rendering data visualizations. The project is distinguished by its engine abstraction, which allows users to switch between different JavaScript charting libraries without modifying the underlying data sources. It also supports asynchronous data visualization, fetching chart data from remote

F Prime is a component-based framework designed for the development and deployment of embedded and spaceflight software. It provides a modular architecture that decouples software logic from communication interfaces, allowing developers to define system structures through a domain-specific modeling language. This model-based approach enables automated code generation, ensuring consistency across complex system topologies while maintaining strict interface contracts between software modules. The framework distinguishes itself through its integrated build system and ground data operations suite

jemalloc is a general purpose C memory allocator designed as a replacement for the standard library malloc and free functions. It is a multi-threaded allocation library that emphasizes fragmentation avoidance and scalable concurrency for high-performance applications. The project reduces lock contention by using multiple independent memory arenas and thread-local cache layers. It minimizes latency by offloading the reclamation of unused memory pages to asynchronous background threads and utilizes huge page metadata storage to reduce translation lookaside buffer misses. The system includes a

NSLogger is a remote logging framework and binary data logger designed to stream application traces from devices to a dedicated network log viewer. It enables the transmission of system traces over a network, utilizing SSL encryption to ensure secure telemetry transmission. The system distinguishes itself by supporting the embedding of raw binary data and images directly into log streams for visual inspection within the viewer. It also includes an offline log buffer that stores traces locally during network outages and automatically transmits them once connectivity is restored. The framework

Mimalloc is a general purpose dynamic memory allocator for C and C++ designed to increase execution speed and reduce fragmentation. It functions as a scalable heap manager that replaces standard library allocation functions to improve performance and memory efficiency across applications. The project distinguishes itself as both a heap security hardener and a memory corruption detector. It employs randomized allocation, encrypted free lists, and sampled guard pages to mitigate heap exploits and identify buffer overflows or use-after-free errors during runtime. The allocator provides capabili

stats.js is a JavaScript performance monitor and visual diagnostic tool. It provides a real-time overlay for tracking frame rates, memory allocation, and the rendering efficiency of web graphics and applications. The project includes a visual meter for measuring frames per second and a browser memory profiler that displays allocated memory in megabytes to help detect resource leaks. It is designed as a web graphics debugger to monitor the efficiency of WebGL and Canvas rendering. The tool covers a range of monitoring and observability capabilities, including the creation of custom performanc