Open-source alternatives to Debug

Zerolog is a structured logging library for Go designed for high-performance event capture and observability. It focuses on generating machine-readable JSON output while minimizing memory overhead through zero-allocation buffer encoding and strongly-typed field validation. The library distinguishes itself by providing a chainable, context-aware interface that allows developers to bind trace identifiers and metadata directly to request lifecycles. It supports complex diagnostic workflows by enabling independent logger instances, custom output routing to multiple concurrent destinations, and ev

SwiftyBeaver is an extensible logging framework for Swift that routes log output to multiple destinations simultaneously, including the Xcode console, local files, and remote cloud services. It supports recording messages at distinct severity levels with corresponding visual styling, and can attach arbitrary contextual data such as numbers, arrays, or dictionaries to log entries without requiring manual string conversion. The framework distinguishes itself through destination-based log routing, where each output target can have its own independent format and filter configuration managed by a

Logrus is a structured logging library for Go that produces machine-readable output using key-value pairs and JSON formatting. It serves as a pluggable logging framework providing a thread-safe event logger with configurable mutex locking to manage concurrent writes across multiple goroutines. The project distinguishes itself through a pluggable hook system that routes log entries to external services or custom destinations. It also features a contextual logger capable of attaching persistent metadata and request-scoped fields to entries to improve traceability. The framework covers broad ob

This project is a learning guide and collection of study notes designed to teach Node.js backend development. It provides a comprehensive core API reference and practical demonstrations for implementing server-side logic, network programming, and system APIs. The guide specifically covers advanced technical domains including process management for scaling applications via clusters and child processes, as well as network programming for building TCP, UDP, and HTTP services. It also includes detailed instructional material on security implementation, focusing on cryptographic hashing and encryp

node-inspector is a web-based debugger for Node.js applications that integrates the Blink developer tools interface. It functions as a runtime profiler and inspection suite, providing a remote debugging interface to connect a local browser to a Node.js process. The project enables live code iteration, allowing source code to be modified while the process is running and persisting those changes back to the physical file system. It also includes a JavaScript runtime profiler to monitor CPU and heap usage for identifying bottlenecks and memory leaks. The tool covers execution flow control throu

Django Silk is a profiling and inspection toolset for Django applications designed to capture SQL queries, HTTP request data, and execution timing for diagnostics. It functions as a performance profiler and debugging middleware that records runtime execution data to provide a comprehensive overview of application behavior. The system includes a database profiler for identifying slow operations through detailed timing data and an HTTP request inspector for reviewing headers, bodies, and network traffic via a web interface. It allows for the reproduction of specific server requests through gene

This Android logging library is a toolkit for printing formatted, stylized, and filtered debug messages to the Android console and local files. It functions as a console log styler, a log file writer, and a formatter for converting complex data into human-readable text. The library provides specific utilities for customizing the visual appearance of logs by tracking thread information and call depth. It includes capabilities for converting JSON, XML, and collection data into readable formats and saving console entries to local files for offline analysis. The system covers broader log managem

structlog is a structured logging library for Python that treats log entries as dictionaries instead of strings. This data-centric approach enables machine-readable output and precise data analysis by generating log entries as key-value pairs. It functions as both a standalone logging framework and a compatibility layer that adds structured capabilities to the Python standard library logging module. The library features a processor-pipeline architecture that passes log dictionaries through a sequence of functions to modify events or add metadata before final rendering. It includes a contextua

Unreal.js is a JavaScript runtime and scripting layer for Unreal Engine that embeds the V8 engine to implement game logic and manage application state. It provides a bridge for writing high-level application behavior and actor control without modifying the core engine source code, as well as a framework for extending the Unreal Engine editor with custom interface elements. The project distinguishes itself through a V8-based integration that supports real-time code reloading and live iteration, allowing scripts to be updated without restarting the application. It includes a bidirectional commu

Signale is a formatted console logging library for Node.js applications. It serves as a pluggable logging framework and stream-based log router that allows users to record system events using customizable levels, colors, and output styles. The project distinguishes itself as an interactive console logger capable of overwriting previous messages to reduce terminal clutter during long-running tasks. It also functions as an application performance monitor, providing tools to measure and track execution time between specific code points to identify performance bottlenecks. The library covers a b

Easyloggingpp is a C++ logging library and thread-safe logging framework used for recording diagnostic messages and application events. It functions as an asynchronous logger, processing messages on a background thread to reduce latency and prevent blocking the main execution path. The project includes a log rotation manager to automatically truncate or roll over files once they reach a specified disk size limit. It also serves as a performance tracking tool for measuring function execution timing and recording checkpoints to identify processing bottlenecks. The library covers a broad range

Pino is a high-performance logging library for Node.js applications designed to minimize overhead and prevent blocking the main event loop. It generates machine-readable logs using newline-delimited JSON, facilitating efficient ingestion and analysis by external monitoring and log aggregation platforms. The library distinguishes itself by offloading log processing and formatting to worker threads, ensuring that heavy logging tasks do not impact application responsiveness. It also provides a decoupled command-line utility that transforms structured production logs into human-readable text, sim

This is a logging framework for Node.js based on the log4j architecture. It provides a system for managing hierarchical loggers and severity thresholds, allowing application events to be recorded and categorized across different levels of importance. The framework is distinguished by its cluster-aware logging, which synchronizes and coordinates output across multiple process clusters into a unified stream. It also includes a dedicated log file rotation manager that automatically rolls files by date or size to prevent disk space exhaustion, and a network log transporter for sending data to rem

Icecream is a Python debugging utility designed for inspecting variable values and execution flow during development. It provides a variable inspector that automatically labels values and attaches file and line number metadata to each output. The tool features a builtins injector that adds debugging functions to the global namespace, allowing for universal access across all project files without manual imports. It also includes an inline debugging tool that returns its arguments to the caller, enabling the insertion of inspection calls directly into active expressions without altering program

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

go-spew is a deep inspection library and debugging utility for Go. It functions as a data structure pretty printer that renders complex, nested types into human-readable strings with indentation and type information. The library provides specialized capabilities for visualizing internal program states, including the ability to dump data structures with pointer addresses and map keys. It includes a configuration system to adjust printing behavior, such as limiting recursion depth and setting indentation. The tool uses reflection-based type inspection and recursive tree traversal to handle nes

Colored pretty printer for Go language

Consola is a diagnostic logging utility and log output manager that provides a unified interface for Node.js and web browser environments. It functions as a scoped logging framework and a tool for capturing user text, confirmations, and selections through interactive console prompts. The project distinguishes itself through a system for creating specialized logger instances with inherited defaults and unique tags for contextual tracking. It also features a pluggable reporter interface that allows for the redirection of standard output to custom logging destinations and external reporters. Th

AWS Powertools for Python is a utility framework designed for building production-ready Python functions on AWS Lambda. It provides a comprehensive suite of tools for observability, event parsing, routing, and idempotency management to streamline the development of serverless applications. The project distinguishes itself through specialized capabilities for event-driven architectures and AI agent orchestration. It enables the implementation of AI agents by exposing functions as tools via OpenAPI schemas and managing conversation states. Additionally, it features an idempotency library that p

Loguru is a Python logging library and thread-safe framework designed for recording system events and diagnostic messages. It functions as a structured logging tool that can serialize messages into JSON strings with metadata for automated parsing and analysis. The library includes a specialized exception tracker that captures unhandled crashes across main and background threads, rendering detailed stack traces that include local variable values. It further distinguishes itself through a unified routing pipeline that can intercept messages from the standard library logging module and dispatch

re-frame is a functional framework for building single-page applications in ClojureScript. It provides a centralized, immutable database that serves as the single source of truth for the entire application state, enforcing a strict unidirectional data flow where events trigger state transitions and subsequent view updates. The framework distinguishes itself through a reactive signal graph and an interceptor-based middleware pipeline. By treating application logic as a sequence of data-driven events and declarative side effects, it decouples business logic from the view layer. This architectur

Ergo is a distributed actor framework for Go that implements the Erlang distribution protocol, enabling the construction of resilient, concurrent applications that can communicate transparently with Erlang/OTP nodes. At its core, it provides an actor model with isolated lightweight processes, priority-ordered mailboxes, and a meta-process architecture that separates blocking I/O from sequential message handling to prevent actor freezing. The framework includes a Raft-inspired cluster consensus system for leader election and automatic failover, along with OTP-style supervision trees that organi

xcpretty is an xcodebuild log formatter and CI build log parser that transforms verbose compiler output into concise, readable logs. It serves as a build report generator and an Xcode test result visualizer, converting raw build and test data into simplified formats for developers and continuous integration pipelines. The tool differentiates itself by providing specialized visualizations for test execution, such as dot-style result rendering and the measurement of runtimes to identify performance bottlenecks. It also functions as a report generator capable of exporting build results into stan

phpdotenv is a PHP environment variable loader and configuration parser. It reads key-value pairs from files and populates them into PHP system environment variables and global arrays to avoid hardcoding sensitive settings in code. The project includes a configuration variable interpolator to resolve nested references and variables within environment files. It also provides an environment variable validator to ensure required variables exist and match specific data types or values. The system covers application secret management, multi-environment deployment, and the parsing of raw configura

This project is a browser developer tool designed for inspecting JavaScript execution, network traffic, and page layouts. It functions as a JavaScript debugger and a Chrome DevTools Protocol debugger to manage the state of a web engine and identify logic errors in web applications. The suite provides specialized utilities for web performance profiling, including the detection of memory leaks and the analysis of processing bottlenecks. It also includes a network traffic analyzer for troubleshooting API calls and a browser storage manager for modifying cookies, cache, and local database entries

env is a Go library that reads environment variables and populates the fields of a Go struct according to tag directives. It uses reflection to iterate over struct types and tags at runtime, mapping environment variable names to struct fields and applying parsing behavior defined in struct tags. The library supports required field validation, returning errors when marked fields are missing or empty after parsing. It also provides default value fallback from struct tags when environment variables are not set, environment variable expansion that recursively substitutes references within values,

Stern is a Kubernetes command-line debugging tool and log aggregator designed for streaming and filtering logs from multiple pods and containers. It functions as a log tailing utility that consolidates real-time data from distributed resources into a single, color-coded output. The tool uses regular expressions to select pods and filter log content, allowing for the isolation of specific system events. It automatically tracks the lifecycle of resources, using a watch mechanism to attach to new pods that match filter criteria and removing deleted ones from the active view. Capabilities includ