Open-source alternatives to Stern

Freelens is a graphical web dashboard for Kubernetes cluster administration and monitoring. It provides a centralized interface for managing container orchestration environments, featuring a log aggregator for simultaneous multi-pod log viewing, a resource visualizer for mapping system dependencies via force-directed graphs, and a security auditor for reviewing vulnerability reports and certificate expiration dates. The project integrates a generative artificial intelligence operator to automate complex administrative tasks and translate requests into cluster configurations. It further distin

lnav is a terminal-based log viewer and analyzer designed for aggregating, filtering, and analyzing multiple log files in a single chronological view. It functions as a console application that can replace the system pager, providing syntax highlighting and document navigation for system or application logs. The project distinguishes itself by mapping unstructured log data to virtual SQLite tables, enabling the use of SQL and PRQL for structured data analysis, aggregations, and relational queries. It further differentiates its capability set through native integration for retrieving and taili

Scribe is a distributed log aggregation system designed to collect and route real-time log data from numerous servers to centralized storage or analysis tools. It functions as a log data pipeline and scalable collector that gathers streaming data and writes it to local disks or remote endpoints. The system employs a log routing server model that organizes incoming streams into specific buckets based on predefined configuration mappings. It supports multi-hop log forwarding, allowing data to be routed through a chain of intermediate servers to centralize logs from diverse network segments. Re

Tailspin is a regex-based text colorizer and terminal log viewer designed to transform plain text streams into colorized output. It functions as a command line log highlighter and tailer that applies syntax highlighting to logs using regular expressions. The tool distinguishes itself through its ability to monitor files in real time and pipe live output through a highlighter. It recognizes and colors common data types such as IP addresses, UUIDs, HTTP methods, JSON objects, dates, and memory pointers. Users can define custom highlight styles and regex patterns to assign specific colors to uni

Devspace is a Kubernetes development workflow tool and declarative deployment orchestrator. It automates the build, deploy, and debug cycle for applications running inside Kubernetes clusters, functioning as a container image pipeline automator and a remote Kubernetes debugger. The project features a Kubernetes hot reloading engine that provides real-time code synchronization and bi-directional file synchronization between local filesystems and running containers. This allows for updates without requiring image rebuilds or restarts. It further enables environment parity by running build, test

Logspout is a container log aggregator, forwarder, and routing engine designed to gather logs from Docker containers and route them to centralized external logging systems. It functions as a network-based utility that pipes container output to remote destinations such as syslog or TCP endpoints. The system features a dynamic routing engine that allows the creation and updating of log routing configurations and destination filters in real time via an HTTP interface without restarting the service. It utilizes an adapter-based architecture, enabling the development of custom output modules and t

NLog is an open-source logging framework for .NET that functions as a structured logging library and log routing engine. It captures log events with named parameters as searchable data rather than plain text and directs these messages to various output destinations based on severity and source. The framework is designed as an extensible platform, supporting custom targets, layout renderers, and filters that can be loaded from external assemblies or defined in code. It features a dynamic configuration system that allows logging targets, rules, and layouts to be updated via XML or programmatic

This project is a Spring Cloud microservices boilerplate and distributed system infrastructure designed to accelerate the development of enterprise Java applications. It provides a reference architecture that combines a Java backend with a decoupled Vue.js frontend framework. The system includes a complete e-commerce reference implementation, featuring a digital storefront with a full shopping workflow and a backend operations platform for business management. It also integrates OAuth 2.0 for identity management, supporting stateless authentication and third-party login services. The infrast

The Kubernetes Python Client is a programmatic interface for cluster automation and resource management. It provides a REST-based API client that maps method calls to HTTP verbs and JSON payloads to create, update, delete, and monitor workloads and infrastructure components. The client features dynamic schema mapping and resource mapping, allowing it to control custom objects and unique resource definitions without requiring pre-defined classes or static schemas. It supports YAML manifest parsing to convert structured files into compatible objects for bulk resource deployment. The toolset co

Battery Historian is a visualization and profiling tool for analyzing power consumption and battery drain on Android devices. It functions as a bugreport viewer and power consumption profiler that parses system logs to extract battery statistics and kernel data into a web-based interface. The tool specializes in correlating disparate data sources on a synchronized chronological timeline. It identifies power-draining activities by tracking userspace and kernel wakelock transitions, mapping kernel wakeup sources to real-time timestamps, and overlaying external hardware power monitor logs onto s

Highly extensible platform for developers to better understand the complexity of Kubernetes clusters.

ngxtop is a real-time web server dashboard and traffic analyzer that transforms raw Nginx access logs into immediate visual metrics. It functions as a live monitor for tracking request rates, response codes, and bandwidth usage by parsing server logs as they are written. The tool extracts performance data from combined, common, and JSON log structures. It uses these parsed logs to identify high-traffic endpoints and server error patterns for troubleshooting. The system processes log streams through a pipeline that includes schema-based extraction, record filtering via evaluatable expressions

Mods is a terminal-based AI client that sends prompts to large language models and streams responses back to the command line. It functions as a multi-provider AI gateway, routing queries to OpenAI, Cohere, Groq, Gemini, and local endpoints, and includes a conversation history manager that saves, caches, branches, and resumes text-based interactions. The tool also operates as a Model Context Protocol client, connecting to external MCP servers via stdio, SSE, or HTTP to extend model capabilities with specialized tools and data. The project distinguishes itself through a config-driven provider

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

This is a framework for building structured terminal applications in Go. It provides the core components necessary to define a command-line interface, including a system for managing commands, sub-commands, and their associated flags. The library distinguishes itself through an automated help generator that produces formatted usage instructions and manual pages, and a shell completion generator that creates tab-completion scripts for Bash, Zsh, Fish, and PowerShell. It also features a command lifecycle manager to handle pre- and post-execution logic and process exit codes. The toolkit covers

The Operator SDK is a framework for building, packaging, and managing custom controllers that extend the Kubernetes API. It serves as a toolset for defining new API types and implementing reconcile loops to automate the lifecycles of complex applications. The project provides specialized support for creating operators based on Helm charts or Ansible playbooks, allowing users to maintain a desired cluster state using existing automation tools. It includes a dedicated system for packaging controllers into standardized container image bundles for distribution via the Operator Lifecycle Manager.

yargs is a command-line interface framework and argument parser for Node.js. It translates raw command-line strings into structured JavaScript objects, providing a toolkit for building terminal applications with nested sub-commands, dedicated handlers, and a structured user interface. The framework distinguishes itself through automated help text generation, which constructs formatted usage menus and instructions based on registered metadata. It also provides shell completion generation for Bash and Zsh and uses string-distance algorithms to offer typo correction suggestions when invalid inpu

probe-rs is an embedded debugging toolset used for flashing, debugging, and inspecting microcontrollers via hardware debug probes. It functions as an embedded firmware flasher, a memory manager for reading and writing to processor registers, and a server implementing the Debug Adapter Protocol to connect hardware debugging to various code editors. The project includes a CMSIS-Pack target parser to extract device metadata and flash configurations from industry-standard definition files. It provides a driver-based probe abstraction to interact with various hardware debug probes regardless of th

Cobra is a development framework for building command-line applications in Go. It organizes application logic into a hierarchical tree structure where each node represents a command, complete with its own flags and execution logic. This structure allows developers to build complex, nested command interfaces that mirror business domains while maintaining a clean separation between command orchestration and underlying business logic. The framework distinguishes itself through its declarative approach to metadata and configuration. It automatically derives help documentation, usage instructions,

Goatcounter is a privacy-focused web analytics platform designed to be self-hosted on your own infrastructure. It collects visitor statistics like page views, browser information, location, screen size, and referring sites without using cookies or storing any personal data, identifying unique visits through a non-identifiable hash derived from browser and network data. The platform distinguishes itself by offering multiple tracking methods that respect user privacy, including a lightweight JavaScript snippet, an image-based tracking pixel for environments without JavaScript, and the ability t

usql is a universal SQL command-line interface used to connect to and manage multiple SQL and NoSQL databases through a single unified tool. It provides a standardized interface for executing queries across various data stores and serves as a multi-database query tool and schema inspector. The tool distinguishes itself by enabling cross-database data migration, allowing users to pipe result sets from one active database connection directly into another. It also features terminal-based data visualization, which renders query results as graphical charts, graphs, and images directly within the t

Hexyl is a colored hex dump utility and binary data viewer for the terminal. It allows for the inspection of binary files by rendering contents as a colored hex dump to distinguish between different byte categories, such as printable text, whitespace, and null bytes. The tool includes a C-style hex exporter that transforms binary data into C include files for direct integration into source code. It supports visual layout customization through configurable panels and borders, as well as the ability to define colors for byte categories and offsets using terminal colors or RGB hex codes via envi

tdl is a command-line tool for Telegram account automation, media management, and data archiving. It provides a programmatic interface for downloading and uploading files, forwarding messages, and exporting chat history, member lists, and media into structured JSON files. The project distinguishes itself through a session management system that isolates multiple account identities using unique namespaces. It features expression-based routing for messages and uploads, allowing users to direct content to specific destination chats using custom logic and dynamic caption generation. The tool cov

Vector is a high-performance observability data pipeline designed to collect, transform, and route logs, metrics, and traces across distributed infrastructure. It functions as a modular engine that decouples data ingestion from processing and transmission, utilizing a component-based architecture to connect diverse sources to multiple destinations. The project distinguishes itself through a focus on reliability and flow control. It implements backpressure-aware data movement to prevent data loss during traffic spikes and utilizes disk-backed event buffering to ensure durability during network

HertzBeat is a real-time observability platform that provides agentless monitoring for servers, databases, and networks. It functions as an infrastructure alerting manager, an OpenTelemetry Protocol log aggregator, and a public status page generator. The platform integrates an analysis engine that uses large language models to process monitoring data and generate system insights. It utilizes a cloud-edge collaborative architecture and distributed collector clustering to scale data gathering across large-scale networks. The system covers a broad range of observability capabilities, including

The logging operator is a Kubernetes-native controller designed to automate the deployment, configuration, and lifecycle management of log collection and routing infrastructure. By utilizing custom resource definitions, it provides a declarative framework for standardizing how container logs are captured, processed, and forwarded across distributed cluster environments. The project distinguishes itself through its support for multi-tenant logging architectures, allowing administrators to enforce namespace-scoped isolation for log collection and routing configurations. It employs a sidecar inj

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