Chucker is a production-grade Android library for inspecting HTTP(S) traffic in-app. It acts as an OkHttp interceptor, capturing full request/response details (headers, bodies, timing, errors) and persisting them to a local Room database. The library provides a built-in Material Design UI for browsing, searching, filtering, and exporting transactions (HAR 1.2, plain text, curl commands). It is designed as a debug-only tool via a no-op variant for release builds. The architecture follows a clean separation: public API (ChuckerInterceptor, ChuckerCollector, BodyDecoder), internal data layer (Room entities, DAO, repository), support utilities (okio stream manipulation, JSON formatting, background services), and a full set of UI fragments/adapters. The codebase is well-tested (unit tests for interceptors, DAO, repository, utilities, ViewModels) and follows modern Android development practices (Kotlin, Coroutines, LiveData/Flow, ViewBinding, Compose sample). It handles edge cases like compressed bodies, large payloads, binary formats (protobuf), GraphQL, and SSL/TLS information. The project also includes CI/CD pipelines, automated dependency updates via Renovate, and migration guides for previous versions. While primarily an application library, it has a strong data storage component (Room database) and export functionality (HAR generation), making it useful for debugging network issues in any Android app.
GammaRay is a mature runtime introspection and manipulation tool for Qt applications, not a data or research project. In production it injects a probe into a target Qt process via a launcher that supports preload, GDB/LLDB, and Windows DLL injection, then connects a Qt Widgets client either in-process or over TCP. The probe tracks QObjects, exposes their properties, signals/slots, object trees, widget hierarchies, QML scene graphs, model/view contents, state machines, network activity, and even records and replays QPainter command streams. The core machinery uses a custom client-server protocol built around Endpoint, ObjectBroker, remote models, and network-synchronized selection models, with lazy-loading proxy models on the client side. The architecture is modular: a shared protocol layer in common/, a server-side core with property adaptors, tool managers, and remote model servers, a client UI layer, and dozens of plugin-based inspectors. Each plugin follows a consistent pattern - a server-side tool, a client-side widget, and interface classes registered through the ObjectBroker. The codebase shows strong engineering discipline: consistent abstractions, extensive Qt Test based tests, CI workflows for multiple Qt versions and sanitizers, and careful handling of cross-process model synchronization. The main technical risk is heavy use of Qt private APIs (e.g., QPaintBuffer, QQuickItemPrivate, QObjectPrivate) and vendored third-party code, which creates fragility across Qt releases and platform-specific maintenance overhead. Overall this is a well-crafted, complex desktop application. It is not a general-purpose library; most of its value for reuse lies in its plugin patterns and a few isolated Qt utility components. The generic, low-coupling pieces like PropertyBinder, SearchLineController, DeferredTreeView, and UIStateManager can be lifted into other Qt projects with minimal modification.
WAT is a zero-dependency Python library for deep runtime inspection of objects. It provides a single `wat` object that can be used via `wat / obj`, `wat(obj)`, or `obj | wat` to display the object's type, value, attributes, methods, signatures, docstrings, source code, and more. The library supports a rich set of modifiers (short, long, dunder, code, caller, public, all) that can be chained fluently. It also offers `wat.locals` and `wat.globals` to inspect variable scopes. A notable feature is the ability to load the entire inspector without installation via a base64-compressed snippet or even a single Unicode glyph, making it extremely portable for debugging in any Python environment. The codebase is a single well-structured module with comprehensive test coverage, demonstrating solid Python engineering practices including operator overloading, AST manipulation for minification, and careful handling of edge cases in object introspection.
memory_graph is a Python library for visualizing the structure of Python data as graphs, primarily used for debugging and teaching concepts like references, mutability, and shallow/deep copy. It takes any Python data (e.g., locals(), call stack frames) and generates a Graphviz-based graph (PDF, PNG, SVG) showing the hierarchical relationships and shared references. The library supports multiple node types (leaf, linear, key-value, table), configurable slicing to limit graph size, call stack visualization with IDE-specific stack frame filtering, and extensions for numpy, pandas, and PyTorch types. It is designed to be used interactively in debuggers (VS Code, PyCharm, etc.) or programmatically via functions like `show()`, `render()`, and `block()`. The codebase is well-structured with clean separation of concerns (node types, slicing logic, configuration, HTML table generation) and includes unit tests for core components.
This repository contains a Unity Editor tool for monitoring and visualizing PlayableGraphs in real-time. The tool displays the topology of PlayableGraphs showing nodes and connections, allows inspection of node details (playable properties, clip information, etc.), and provides UI controls for layout, refresh rate, and visibility options. It implements a modular architecture with separate concerns for the main window, graph view, node representations, object pooling, and utility functions. The tool supports various Playable node types with specific visualizations and handles edge cases like circular references in PlayableGraphs.
DWARF Explorer is a cross-platform GUI utility for visualizing DWARF debugging information in executable files. Built on PyQt6, pyelftools, and filebytes, it allows users to open ELF, Mach-O, PE, WASM, and ar files to browse their DWARF debug information tree. The application provides views for DIEs (Debugging Information Entries), attributes, references, and includes specialized tools for analyzing locals at addresses, function maps, data sections, frame information, and unwind data. The architecture follows a modular design with clear separation between the GUI layer (PyQt6-based interface in __main__.py and ui.py) and the DWARF analysis logic. Core functionality includes parsing various binary formats via formats.py, building and navigating the DIE tree through tree.py and die.py, and performing specialized analyses using utilities in dwarfutil.py, locs.py, and other modules. The application supports features like following DIE references, searching by conditions, highlighting DIEs, and exporting C skeletons. Key strengths include robust error handling with crash reporting, support for multiple binary formats and DWARF versions (including experimental v1 support), and thoughtful UI design with keyboard navigation, bookmarking, and detailed views. The code demonstrates good practices in separating concerns, with reusable components like the Mach-O unwind parser that could be extracted for use in other projects.