Terminal Based System Resource Monitors

neohtop is a terminal-based system resource monitor and process manager for Linux. It provides a text-based user interface for tracking CPU and memory usage and managing active system tasks without requiring a graphical desktop environment. The utility functions as a live dashboard for observing hardware performance and resource allocation. It enables users to search, filter, and terminate system processes, with the ability to pin specific entries to ensure they remain visible during monitoring. The tool covers general system observability and process management, allowing users to isolate specific tasks via search terms and reorganize process lists through column-based sorting.

Glances is a cross-platform system monitoring tool designed to track real-time resource usage and hardware health metrics across diverse computing environments. It functions as a command-line utility that provides a unified view of system performance, identifying bottlenecks and maintaining infrastructure stability through a consistent abstraction layer that translates kernel calls into actionable data. The project distinguishes itself through its distributed capabilities, offering a web-based interface that enables remote access to live performance metrics from any device without requiring direct terminal access. It also operates as a telemetry data exporter, utilizing an export-driven pipeline to stream collected statistics to external databases and monitoring tools for long-term historical analysis. The system supports a modular architecture that allows for extensible data collection through independent scripts. It facilitates remote monitoring by maintaining persistent network connections between lightweight data providers and centralized management interfaces.

Btop is a terminal-based system monitor that tracks and displays real-time hardware performance metrics. It functions as a resource usage dashboard, providing visibility into processor, memory, disk, network, and active process activity directly within a text-based interface. The application utilizes ANSI escape sequences to render complex graphical interfaces and data visualizations within standard terminal emulators. It is designed as a cross-platform performance tool, maintaining consistent monitoring capabilities across various Unix-like operating systems through a platform-agnostic build abstraction. Users can manage the application's runtime behavior and visual configuration through command-line arguments or persistent local configuration files. The tool supports granular control over settings such as update rates, themes, and process filters, and includes functionality for monitoring graphics hardware performance.

Textual is a Python TUI framework and asynchronous UI library used to build interactive text user interfaces. It provides a component-based architecture for creating cross-platform applications that run in both terminal and web browser environments. The framework distinguishes itself by utilizing a CSS-based layout engine to apply visual styles to widgets and a command palette interface for discovering and executing application functions. It also supports hosting terminal-based interfaces on the web to enable remote access via a standard browser. The toolkit covers a broad range of capabilities including asynchronous UI programming, widget-based layout composition, and terminal emulation. It includes observability tools for console debugging that allow system messages and events to be captured in a separate terminal instance.

stats.js is a JavaScript performance monitor and visual diagnostic tool. It provides a real-time overlay for tracking frame rates, memory allocation, and the rendering efficiency of web graphics and applications. The project includes a visual meter for measuring frames per second and a browser memory profiler that displays allocated memory in megabytes to help detect resource leaks. It is designed as a web graphics debugger to monitor the efficiency of WebGL and Canvas rendering. The tool covers a range of monitoring and observability capabilities, including the creation of custom performance panels to track application-level indicators. It identifies rendering bottlenecks and stutters by providing live data on render timing and memory usage.

Node Problem Detector is a Kubernetes-native agent that monitors node health and reports hardware failures, kernel issues, and other node-level problems to the cluster control plane. It detects problems by scanning kernel ring buffer messages for error patterns, running user-defined health check scripts, and collecting system metrics from CPU, memory, disk, and network interfaces. The agent distinguishes between permanent and temporary problems by mapping plugin failures to either persistent node conditions visible in kubectl describe node or one-time node events. It supports running multiple custom plugins concurrently with configurable concurrency limits, and can execute repair commands on unhealthy node components after a cooldown period. The detector also monitors systemd service health by scanning journald logs for repeated start/stop patterns, and checks for read-only filesystems or filesystem corruption. Beyond problem detection, the agent collects system health metrics from /proc files on Linux and gopsutil on Windows, exposing them as Prometheus endpoints for external scraping. It includes built-in monitoring for CPU load averages, memory usage, disk I/O operations, network interface statistics, and host uptime. The project provides container images for both Linux and Windows deployments, and creates a dedicated Kubernetes service account with cluster role bindings for node problem detection permissions.

Memray is a memory profiler for Python that tracks heap allocations in both Python code and native C or C++ extensions. It captures memory events by hooking into the language runtime and traversing call stacks, providing a comprehensive view of how an application consumes memory. The tool is designed to minimize performance impact on the target application by using thread-local buffering and streaming data to an external process or file. The project distinguishes itself through its ability to monitor complex, multi-threaded systems and child processes in real-time. It provides diagnostic utilities that allow developers to attach to running processes, filter memory data by specific threads, and visualize allocation patterns through interactive flame graphs. These graphs support temporal inspection, enabling users to analyze memory usage across specific time intervals during execution. Beyond live monitoring, the tool includes mechanisms for automated memory validation and regression testing. It can detect memory leaks by identifying objects that remain in memory at the end of a session and allows developers to enforce resource consumption thresholds within continuous integration pipelines. The profiler also generates detailed statistics and hierarchical call graphs, which help pinpoint inefficient allocation patterns such as frequent, short-lived object creation.

Mole is a terminal-based utility designed for comprehensive system maintenance, storage management, and real-time hardware monitoring. It provides a command-line interface for users to analyze disk usage, track system health metrics, and perform routine optimization tasks to maintain machine stability and performance. The project distinguishes itself through a declarative configuration model that uses structured data files to define custom cleanup logic, allowing for precise control over the removal of temporary files and project artifacts. It incorporates a safety-first execution layer that wraps destructive operations in validation checks, ensuring that user intent is verified before any files are modified or deleted. This approach extends to application lifecycle management, where the tool facilitates the complete removal of software binaries along with their associated configuration files and orphaned data. Beyond its core cleanup capabilities, the tool offers a broad suite of maintenance functions, including the clearing of system caches, the removal of redundant installer packages, and the optimization of background processes. It features a recursive file-system traversal engine to identify storage-consuming data and provides real-time visibility into hardware resources such as CPU, memory, and network status. Users can further extend the utility by integrating custom script directories to automate specific workflows directly from the command line.