Projects sharing features with Booster

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 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

The project is a development kit and compilation toolchain that builds C and C++ source files into native machine code libraries and shared library packages for mobile execution. It integrates target architecture toolchains with standard build systems to transform source code into deployable native modules. The toolset includes debugging and profiling capabilities that bridge low-level system debuggers with compiled binaries to inspect runtime execution states, register contents, and memory layouts. It provides performance monitoring instrumentation to measure execution bottlenecks and resour

This project is a thread-safe, asynchronous logging library designed for C++ applications. It provides a comprehensive diagnostic toolkit that enables developers to record system events, track execution flow across multiple threads, and manage log output through severity-based filtering and automated file maintenance. By offloading log formatting and disk input/output to background worker threads, the library minimizes latency on the main execution path, ensuring high performance in time-critical systems. The framework distinguishes itself through its flexible configuration and diagnostic cap

Excelize is a library for reading and writing spreadsheet files in the Office Open XML format. It provides a comprehensive suite of tools for programmatically creating, modifying, and analyzing workbooks, worksheets, and cell data, ensuring compatibility across various office software suites through structured XML serialization. The library distinguishes itself with a built-in formula calculation engine that evaluates complex mathematical and logical expressions directly against workbook data. It also features a memory-mapped streaming architecture, which allows for the efficient processing o

Byte Buddy is a runtime code generation and bytecode manipulation library for Java. It provides a fluent API for creating and modifying Java classes during execution, enabling developers to define class structures, methods, and fields programmatically without requiring a compiler or direct bytecode assembly. The library supports agent-based class transformation, allowing loaded classes to be modified during JVM startup or runtime through a Java agent that intercepts class loading. It offers bytecode-level method interception for fine-grained control over method behavior, annotation-based code

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

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

Powermock is a Java mocking framework and unit testing tool that uses bytecode manipulation to mock static methods, final classes, and private constructors. It includes a Java agent instrumentation tool and a reflection-based testing utility to bypass encapsulation and modify class behavior at runtime. The project distinguishes itself by providing the ability to intercept the instantiation of objects via the new keyword and simulate the behavior of core Java system classes and native methods. It can override final modifiers on classes and methods and bypass signature restrictions for classes

Aliucord is a modified version of the Discord Android application that functions as a plugin-based app extender. It allows for the installation of third-party plugins and deep customization of the mobile client without requiring a full rebuild of the binary. The project provides a framework for loading external code modules at runtime and includes a management system for installing and updating these extensions. It features a dedicated telemetry blocker designed to prevent the application from sending tracking and analytics data to remote servers. Additional capabilities include a crash logg

Lombok is a Java annotation processor and boilerplate reduction library designed to automatically generate repetitive source code. It intercepts the compilation process to inject methods and fields directly into Java classes, acting as a source code generator that eliminates the need to manually write common class patterns. The project distinguishes itself through deep integration with the Java compiler and various integrated development environments. It provides IDE plugins that allow editors to recognize and navigate generated methods, preventing false compilation errors and maintaining syn

This project provides a collection of patches and modification sets for Android applications. It focuses on enhancing media consumption through the removal of advertisements and sponsored segments, while enabling deep customization of application interfaces and internal behaviors. The project employs system-level modifications, including binary hooking, bytecode manipulation, and dynamic memory patching, to override default application restrictions. These capabilities allow for the restoration of push notifications via signature spoofing, the suppression of screenshot alerts, and the automati

This project is an Android security analysis toolkit and mobile app runtime manipulator designed for reverse engineering and auditing mobile applications. It provides a system for modifying Java classes and method behavior in active mobile processes to bypass security controls. The toolkit includes a web-based interface for controlling the instrumentation engine and a specialized utility for disabling certificate validation to intercept and inspect encrypted network traffic via SSL pinning bypass. It also features an Android file explorer for browsing and managing files within private data di

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

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

Hugo is an annotation-based debugging tool and Java method logging library. It functions as a method execution tracker that records method arguments, return values, and execution durations during application runtime. The project differentiates itself by using annotation-driven instrumentation and bytecode-level aspect injection to capture telemetry without requiring manual print statements. It employs post-compilation bytecode manipulation and aspect-oriented wrapping to insert interception logic around annotated method boundaries. The library covers observability and monitoring capabilities

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

FlameGraph is a performance profiling and visualization toolkit designed to identify bottlenecks in software execution. It functions as a processing engine that transforms raw stack trace samples into interactive, hierarchical diagrams. By representing aggregated execution frequency as nested rectangles, the tool allows developers to visualize hot code paths and analyze system behavior across both kernel and user-space environments. The project distinguishes itself through its ability to perform differential profile analysis, which highlights performance regressions or improvements by compari

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

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

Component is a frontend build tool and package manager designed for modular web application development. It functions as an asset pipeline orchestrator and module dependency resolver, fetching and organizing local or remote code packages according to specific versioning rules. The system provides a development environment that supports local module linking via symlinks for real-time testing without publishing to a registry. It includes a programmable build pipeline to transform scripts and styles into production assets and an event-driven file watching system to trigger automatic recompilatio

btrace is a JVM dynamic tracing tool and performance profiler used for injecting safe instrumentation scripts into a running Java Virtual Machine without requiring a process restart. It functions as a Java agent framework and a Model Context Protocol server, exposing JVM diagnostic operations and tracing tools to large language models and AI assistants. The project distinguishes itself by enabling real-time code injection and bytecode-level instrumentation via a secure binary protocol. It ensures production stability through a static safety analysis engine that blocks unstable code patterns,

SVGR is a tool that transforms static SVG files into reusable React components for direct rendering within user interface trees. It functions as an AST-based code transformer and build-time asset pipeline, parsing SVG XML into an abstract syntax tree to modify elements before generating JavaScript source code. The project integrates an external optimization engine to strip redundant metadata and minify attributes, ensuring vector images are flexible and easy to style. It uses recursive tree traversal to apply these transformations to all nested graphic elements and employs attribute mapping t

gops is a command-line diagnostic toolset for monitoring, profiling, and managing the runtime state of active Go applications. It functions as a runtime diagnostic tool that provides a focused interface for analyzing memory, profiling performance, and monitoring the health of running processes. The tool provides a set of specialized utilities including a performance profiler for capturing CPU and heap profiles, a memory analyzer for identifying leaks and triggering garbage collection, and a process monitor for discovering running binaries and visualizing process hierarchies. The project cove

Dryrun is a command-line tool designed to automate the end-to-end lifecycle of Android projects, including cloning, building, and deploying source code from remote repositories to connected devices. It functions as a build system wrapper and device deployment tool that programmatically invokes native Android build tools to compile applications without requiring manual configuration in an integrated development environment. The project differentiates itself through an ephemeral workspace orchestrator that creates and destroys temporary file system environments to ensure every project execution

bpftrace is a high-level eBPF tracing tool and kernel instrumentation framework for Linux. It provides a tracing language to instrument kernel and user-space events without recompiling the system, functioning as a dynamic system profiler and event aggregator. The project enables dynamic system tracing and Linux kernel observability by capturing tracepoints and dynamic probes in real time. It allows for kernel data inspection and runtime process debugging by accessing internal data structures and filtering specific process events. Its capability surface covers system performance analysis, inc