Open-source alternatives to Debug

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

This is an open-source educational website that translates and localizes MIT's Missing Semester course, teaching practical computing skills for computer science students. The curriculum covers developer tooling, shell scripting, version control, security fundamentals, and open-source collaboration, with a focus on core computing skills including data processing pipelines, workflow automation, secure remote access, shell productivity, Vim editing, and Git version control. The project distinguishes itself by teaching command-line mastery, shell scripting, and automation to boost daily developer

Easyloggingpp is a header-only C++ logging framework and diagnostic tool designed for recording system events and diagnostic messages. It functions as a thread-safe logging library that synchronizes access across multiple concurrent execution threads to prevent data corruption during event recording. The framework features an asynchronous logger that processes messages on a background thread to minimize latency and prevent blocking the main application. It also acts as a log dispatcher, capable of routing data to local files, system syslog facilities, or remote network destinations for system

php-timer is a set of utilities for measuring, tracking, and formatting the execution duration and memory consumption of PHP code segments. It functions as an execution timer and performance profiling utility to analyze resource consumption. The project provides capabilities to track the duration between start and stop triggers in seconds, milliseconds, or nanoseconds. It also includes a resource usage tracker that converts raw execution timestamps and memory bytes into human-readable text strings for reporting. The tool covers performance profiling, resource monitoring, and request duration

PySnooper is a diagnostic library for Python that tracks variable values and execution flow to provide a detailed history of program state. By applying decorators to functions, generators, or classes, it logs line-by-line execution and state changes without requiring manual print statements. The tool distinguishes itself through its ability to monitor nested function calls and concurrent operations in multi-threaded applications. It captures execution context by accessing the current stack frame, allowing for the inspection of local variables and the evaluation of arbitrary expressions during

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

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

Signale is a highly configurable logging library for Node.js applications that provides 16 built-in loggers, each with distinct badges, colors, and labels for different message types. It functions as a console logger that displays timestamps, labels, badges, and filenames in configurable log output, and includes an interactive mode that overwrites previous messages in place for real-time progress indicators. The library distinguishes itself through several advanced capabilities, including a custom logger factory that lets developers create new logger types with unique badges, colors, and labe

Winston is a versatile logging library for Node.js designed to record system events and metadata. It functions as a multi-transport log manager that routes data to various destinations and a structured log formatter that transforms entries into JSON or plain text. The project is distinguished by its pluggable transport architecture, which decouples the logging interface from delivery mechanisms. This allows for the creation of custom transport extensions and the use of hierarchical logger instances to inherit configurations while attaching persistent metadata to downstream messages. The libr

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

This project is a structured logging framework and library for Node.js applications. It produces machine-readable log records in JSON format with tiered severity levels, ensuring consistent parsing and centralized storage. The system includes a log stream manager for routing records to multiple destinations, such as files and consoles, and a command line interface for filtering, formatting, and visualizing raw JSON log streams. It supports the creation of child loggers that inherit parent configurations and merge additional contextual metadata. The framework covers a broad range of operation

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

pretty-ts-errors is a VSCode extension and TypeScript error formatter that converts complex compiler errors into human-readable, visually formatted messages. It functions as a debugging tool that transforms type-checking failures into an improved developer experience within the editor. The tool distinguishes itself by linking type errors to external technical documentation and translation tools for plain-English explanations. It provides integrated navigation that allows users to jump directly from error messages to the corresponding type definitions in the source code. The extension further

Matrix is a suite of mobile application performance management and analysis tools. It provides a plugin-based monitoring system for capturing crashes, lags, and memory leaks, alongside a static binary auditor for reducing installation package size and a bytecode instrumentation tool for performance tracking. The project distinguishes itself through native memory debugging and a SQLite query linter that identifies inefficient database patterns. It employs native interception techniques to detect memory leaks and heap corruption without requiring source code recompilation, and uses a custom run

benchmark.js is a benchmarking and statistical analysis library designed to measure and compare the execution speeds of JavaScript functions. It serves as a performance measurement tool that calculates mean execution time, margin of error, and standard deviation for specific code implementations. The library provides capabilities for comparing benchmark results to determine relative speed and manages organized test suites that can be run, cloned, or reset in bulk. It includes sampling precision controls to adjust minimum sample sizes and maximum run times to ensure statistical reliability. T

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,

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

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

vConsole is a diagnostic interface designed for mobile web environments, providing a visual overlay that allows developers to monitor application state and runtime errors directly on physical hardware. It functions as a mobile-specific debugging console, enabling the inspection of logs, network requests, and storage data without the need for a desktop connection. The tool utilizes a plugin-driven architecture that allows for the creation of custom extensions to address specific troubleshooting requirements. By intercepting browser console methods and wrapping network request objects, it captu

OpenVINO is an AI inference engine and model serving platform designed to execute optimized deep learning models across CPUs, GPUs, and NPUs through a unified API. It includes a model optimization toolkit for converting, quantizing, and compressing models from various frameworks, alongside a specialized generative AI runtime for large language models. The project distinguishes itself through a plugin-based hardware acceleration layer that maps neural network operations to vendor-specific drivers. It features advanced execution mechanisms such as continuous batching, speculative decoding, and

This is a configuration manager for Node.js applications that handles hierarchical settings across different deployment environments. It functions as an environment-based loader and settings parser that merges default configurations with overrides based on the current runtime context and hostname. The project distinguishes itself through a priority-based merge strategy that incorporates environment variables, command-line arguments, and external data sources to supersede file-based settings. It supports multi-format parsing for JSON, YAML, JavaScript, and TypeScript files, and allows for cust

Implementation of a bulletproof node.js API 🛡️

react-native-config is a cross-platform mobile environment manager and native build configuration tool. It implements twelve-factor app configuration principles by separating environment-specific settings from application code. The project provides a mechanism to inject environment variables directly into native project files and build settings during the compilation process. It further functions as a type-safe configuration loader that generates TypeScript definitions for environment variables to ensure autocompletion and safety. The tool manages multi-environment configurations by loading

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

fuckitjs is an automated code pruning utility and error recovery tool for JavaScript. It is designed to isolate and remove breaking lines of code through repeated evaluation and selective excision to ensure a script executes successfully. The tool identifies and excises problematic code segments by iteratively evaluating scripts until runtime crashes are eliminated. It employs a process of identifying and slicing out specific failing lines to mitigate errors and allow a script to run to completion. This capability surface covers automated code cleaning, dynamic script debugging, and JavaScri

Dynaconf is a configuration management library for Python applications that provides a unified system for loading, validating, and managing settings. It aggregates configuration data from multiple files, environment variables, and external stores into a single object using a defined precedence order. The project distinguishes itself through a layered environment manager that separates settings into distinct profiles, such as development and production. It includes a declarative validation framework to enforce data rules and type constraints during the loading process, as well as an external s

OSV is a unikernel operating system and cloud-native execution environment designed to run as a secure microVM on hypervisors such as KVM, Firecracker, Xen, and VMware. It functions as a Linux binary compatible runtime, allowing unmodified Linux binaries to be executed as secure microVMs without requiring recompilation. The project distinguishes itself through its ability to package applications into minimal bootable images and its provide of a virtual machine management API. This REST interface enables remote monitoring of system health, management of execution traces, and control over guest