Awesome GitHub RepositoriesNode.js Debuggers

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

fpm is a multiplatform package builder and converter used to create software packages for various Linux distribution formats from a single unified source. It functions as a Linux distribution packager and a cross-format converter, transforming local directories, existing packages, or language-specific modules into platform-native formats such as DEB and RPM. The tool acts as a language-specific package wrapper, bundling modules from Node.js, Python, Ruby, and Perl into system packages. It can also generate packages that automatically configure system services for targets like systemd. The pr

This project is a JavaScript logging utility and namespace-based debugger used for printing formatted, color-coded debug messages to the console in Node.js, web browsers, and Deno. It serves as a console output formatter and execution time profiler to help identify bugs and track program flow. The system manages debug visibility through named namespaces, allowing specific groups of messages to be enabled or disabled via environment variables. It distinguishes different modules in the output stream by assigning specific colors to these namespaces. The utility includes capabilities for measuri

ndb is a suite of development tools for Node.js that provides runtime inspection, performance profiling, and process management. It functions as a debugger that connects Node.js execution environments to the Chrome browser debugging interface for visual state management and breakpoint control. The tool is distinguished by its ability to detect and attach to spawned child processes, maintaining debugging visibility across multiple process boundaries. It also integrates a source editor that allows users to modify code directly within the debugging interface and save those changes to disk during

pwndbg is a GDB plugin and binary analysis framework designed for reverse engineering, exploit development, and low-level program analysis. It extends the core functionality of the debugger to provide advanced memory inspection and automation tools. The project distinguishes itself with specialized capabilities for heap analysis across glibc, jemalloc, and musl, as well as a comprehensive kernel debugging toolkit for inspecting Linux kernel tasks and slab allocators. It includes an integrated ROP gadget searcher for constructing exploit chains and an LLM-powered debugging assistant that provi

This project is a curated educational guide and instructional resource for the Node.js runtime environment. It serves as a comprehensive introduction to core concepts, including asynchronous programming tutorials, network application primers, and guides on the module system and stream API. The material focuses on the fundamental building blocks of server-side development, specifically how to create reusable code packages and manage project dependencies via a module manifest. It provides detailed instruction on building programs that communicate over HTTP and TCP protocols to exchange data acr

Buck is a multi-language build system and modular build orchestrator designed to compile and package software modules across different programming languages and hardware platforms. It functions as a hermetic build tool, isolating the build process from the host system to ensure consistent and reproducible outputs. The system manages polyglot software builds by organizing code into small, independent units to facilitate faster compilation. It operates as a cross-platform package manager that creates and distributes software components across various operating systems and language ecosystems.

TensorFlow.js is a JavaScript machine learning library and browser-based runtime used to build, train, and execute models. It functions as a WebGL accelerated tensor engine, providing a foundation for high-performance linear algebra operations and an automatic differentiation framework for computing gradients. The project distinguishes itself through its ability to run machine learning directly in web environments, supporting both client-side inference and browser-based training. It enables the deployment of Python-based models by converting Keras or TensorFlow models into compatible formats

Wasm3 is a WebAssembly interpreter designed for embedded runtime integration. It enables the execution of portable binary logic on microcontrollers and resource-constrained hardware, providing support for modules that utilize the WebAssembly System Interface to interact with system resources. The runtime employs register-based bytecode interpretation and direct-threaded dispatch to map virtual registers to physical CPU registers. It includes a host-call interface to map imports to C functions and utilizes static module validation to ensure bytecode follows specification rules before execution

Flux is a Kubernetes GitOps delivery tool used to automate application deployments by synchronizing cluster state with configurations stored in Git, OCI, or Helm repositories. It functions as a set of controllers that monitor desired state in external sources and continuously reconcile the live cluster to match those definitions. The system distinguishes itself through a multi-cluster management plane that coordinates application delivery across fleets of remote clusters from a central hub. It provides a dedicated mechanism for automated image updates, which scans container registries for new

This project is a comprehensive technical guide and diagnostic manual for analyzing memory, performance, and asynchronous behavior within Node.js applications. It provides detailed methods for asynchronous tracing, memory diagnostics, and performance analysis to resolve runtime errors and execution bottlenecks. The resource distinguishes itself by covering advanced diagnostic workflows, including the use of flame graphs for CPU profiling, the capture and comparison of heap snapshots for memory leak detection, and the mapping of asynchronous call stacks. It also provides technical guidance on

Speedscope is a web-based performance profiler that visualizes profiling data through interactive flamegraphs and timeline views. It ingests performance profiles from a wide range of sources, including Chrome, Firefox, Safari, Node.js, .NET Core, Instruments, Hermes, GHC, and Ruby, normalizing them into a common schema for unified analysis. The tool distinguishes itself with a canvas-based rendering engine that draws flamegraphs without DOM nodes for each frame, and a WebAssembly-based rendering pipeline for high-performance drawing. It offers left-heavy stack sorting to surface the most time

Build performant, native and cross-platform desktop applications with native React powerful CSS like styling.🚀

vscode-recipes is a collection of configuration patterns and guides for setting up debuggers and runtime environments within VS Code. It provides standardized templates and blueprints to connect the editor to local, containerized, or serverless runtimes across a variety of programming languages and frameworks. The project focuses on coordinating simultaneous debugging sessions across client-side and server-side processes to trace logic through full-stack applications. It offers specific patterns for integrating language runtimes and orchestrating multi-language development setups within a sin

NGINX Unit is an open-source application server designed to natively execute code across multiple programming language runtimes and WebAssembly within a single process. It serves as a multi-language application server that can run applications written in Go, Java, Node.js, Perl, PHP, Python, Ruby, and WebAssembly side by side, without requiring separate runtime environments for each language. The server distinguishes itself through a RESTful JSON control API that enables dynamic, zero-downtime configuration changes without restarting the server. It combines event-driven asynchronous I/O with

PerfView is a set of integrated profiling and tracing tools built on Windows Event Tracing for Windows (ETW), designed to diagnose CPU, memory, and ETW-based performance issues in .NET applications. It captures ETW events to analyze runtime behavior, CPU usage, and memory allocations, serving as a .NET performance profiler that measures both CPU time and garbage collection events. The tool distinguishes itself with a diff comparison engine that compares two performance traces side-by-side to highlight changes in method costs and event rates. It renders profiled call stacks as flame graphs whe

ActionRoguelike is a third-person cooperative game project built with C++ and Unreal Engine. It functions as a networked application that utilizes replication architecture to synchronize character states and combat across multiple clients. The project implements a data-oriented performance framework that employs object pooling and asynchronous asset loading to optimize memory usage and frame rates. It features a behavior tree AI system combined with environment queries to drive autonomous NPC decision making and combat, alongside a binary serialization framework for saving actor variables and

This project is a PHP debugging toolbar and runtime inspector that provides a browser-based interface for monitoring system metrics, memory usage, and execution time during web development. It functions as an application performance monitor and diagnostic tool, capturing real-time data and application state to visualize the PHP execution lifecycle. The tool distinguishes itself through its ability to persist debug data across multiple requests, allowing for request history tracking and the archival of previous sessions. It supports the inspection of AJAX requests and manages data persistence

HyperDbg is a hardware-assisted kernel-mode debugging platform that leverages virtualization to monitor and control system execution. By utilizing hypervisor-level primitives, it enables deep system analysis and instrumentation without relying on standard operating system debugging interfaces. The framework provides a comprehensive environment for inspecting both kernel and user-mode processes, allowing for granular control over execution flow and system state. The project distinguishes itself through a transparent debugging layer designed to remain invisible to the target environment. It emp

Devtool is a suite of developer tools designed to execute server-side JavaScript code within a browser environment. It functions as a bridge that allows Node.js programs to run inside a Chromium instance, enabling the use of built-in browser developer tools for visual debugging and performance profiling. The project provides a read-eval-print loop for interactive command execution with support for relative imports and piped input. It also includes a file watcher that monitors source files for changes and automatically reloads programs to accelerate the iteration cycle. The system integrates