Uptime Kuma is a self-hosted, open-source uptime monitoring application that periodically checks the availability and response time of services (HTTP, TCP, DNS, databases, Docker containers, and many more) and sends alerts via 90+ notification providers. The system is a monolithic Node.js/Express backend with a Vue 3 SPA frontend, using Socket.IO for real-time updates and SQLite or MariaDB for persistence. It provides status pages, maintenance windows, certificate/domain expiry monitoring, and a Prometheus metrics endpoint. The architecture follows a plugin pattern for monitor types and notification providers, both built on base classes, and includes a condition evaluation system for advanced alerting logic. The codebase is well-structured with clear separation of concerns, extensive tests (unit, integration, e2e), and active community contributions.
This is a Laravel package that monitors scheduled tasks by logging their start, finish, failure, and skip events to a database table. It provides three Artisan commands: `schedule-monitor:sync` to register tasks from the scheduler into a `monitored_scheduled_tasks` table, `schedule-monitor:list` to display their status with visual indicators for late or failed runs, and `schedule-monitor:verify` to check connectivity with the Oh Dear monitoring service. The package integrates deeply with Laravel's scheduling system through event subscribers (`ScheduledTaskEventSubscriber`, `BackgroundCommandListener`) that listen to core scheduler events and update the database accordingly. It also optionally syncs tasks with Oh Dear, pinging external endpoints on task start, finish, or failure, using a queued job (`PingOhDearJob`) with configurable retry logic and custom job support. The architecture is clean and follows Laravel package conventions: a service provider registers macros on scheduler events, configurable model bindings allow custom model classes, and a singleton (`MonitoredScheduledTasks`) stores per-task monitoring configurations (like custom names, grace times, and opt-out flags) using an in-memory array keyed by object hash. While the package is tightly coupled to Laravel's console scheduler and cannot be extracted as a standalone library, its internal patterns—such as the polymorphic `Task` hierarchy (CommandTask, JobTask, ClosureTask, ShellTask) and the `Payload` strategy for building Oh Dear ping data—demonstrate strong software design.
Stats is a native macOS menu bar system monitor that provides real-time hardware and software metrics for CPU, GPU, RAM, Disk, Network, Battery, Sensors (temperature/voltage/fan), Bluetooth, and Clock. Built entirely in Swift with AppKit, it uses private IOKit, SMC, and IOReport APIs to collect system data, and offers highly customizable widgets (mini, line/bar/pie charts, tachometer, text, etc.) drawn directly in the menu bar. The architecture is modular: each monitored subsystem lives in its own 'Module' directory with a consistent structure (main.swift, readers, popup, settings, notifications, portal). A shared 'Kit' framework provides reusable components including a reader base class with interval management and history persistence via bundled LevelDB, a thread-safe key-value store wrapper, and a set of custom drawing chart widgets. The app also supports remote monitoring via an optional cloud service (System Stats), privileged helper for fan control, macOS widget extensions, and extensive localization (40+ languages). The codebase demonstrates strong engineering practices with clean abstractions, encapsulation, and reusability, though some modules exhibit boilerplate duplication and the project relies on several deprecated or private APIs that may require updates for future macOS releases.
HyprMon is a TUI (Terminal User Interface) tool for configuring monitors on Arch Linux running Wayland with Hyprland. It provides a visual 'desk map' where users can arrange monitors using keyboard and mouse controls, with real-time application to Hyprland. The application reads monitor configuration via hyprctl, allows live adjustments, and persists configurations to Hyprland's config files. It features profile management, advanced display settings (HDR, VRR, color depth), monitor mirroring with circular dependency prevention, and automatic workspace migration when monitors are added/removed. Built with Go using the Bubble Tea framework for the TUI and Lip Gloss for styling.
DynamicTp is a Java library for dynamic thread pool management, primarily targeting Spring Boot applications. It allows runtime modification of thread pool parameters (core size, max size, queue capacity, etc.) via configuration centers like Nacos, Apollo, Zookeeper, Consul, Etcd, and Polaris. The library provides a rich set of executor variants (eager, ordered, priority, scheduled) and integrates with over a dozen middleware frameworks (Dubbo, gRPC, RocketMQ, RabbitMQ, Tomcat, Jetty, Undertow, Hystrix, Motan, OkHttp3, Thrift, SofaRPC, Tars, LiteFlow, brpc) by wrapping their native thread pools. It includes comprehensive monitoring and alerting: metrics collection via Micrometer, JMX, and logging; notification channels for DingTalk, WeChat, Lark, email, and custom notifiers; and alarm thresholds for capacity, liveness, rejections, and timeouts. The architecture is modular: a core module defines executors, registries, and lifecycle management; a common module provides utilities, parsers, queues, and SPI extension points; adapter modules wrap middleware executors; starter modules provide Spring Boot auto-configuration; and extension modules add optional features like Redis rate limiting and OpenTelemetry tracing. Key entry points are the @EnableDynamicTp annotation, DtpRegistry for executor registration, and ThreadPoolBuilder for programmatic pool creation. External dependencies include Spring Boot, Guava EventBus, ByteBuddy (for interception), Micrometer, and various config-center client libraries.
This repository contains a Unity Editor tool for monitoring and visualizing PlayableGraphs in real-time. The tool displays the topology of PlayableGraphs showing nodes and connections, allows inspection of node details (playable properties, clip information, etc.), and provides UI controls for layout, refresh rate, and visibility options. It implements a modular architecture with separate concerns for the main window, graph view, node representations, object pooling, and utility functions. The tool supports various Playable node types with specific visualizations and handles edge cases like circular references in PlayableGraphs.
Sentry is a full-stack application for error monitoring, performance tracing, session replay, and observability. In production, it ingests events (errors, transactions, logs, replays, profiles) from SDKs via a Relay proxy, processes them through Kafka streams, and stores data in ClickHouse (Snuba) and PostgreSQL. It exposes a REST API (Django REST Framework) and a React frontend for dashboards, issue management, alerts, and AI-powered features (Seer). The architecture is a monolith with hybrid-cloud services: a control silo for global state, cell silos for regional data, and an API gateway. Key entry points include the Relay ingestion endpoint, the Django WSGI/ASGI server, and Celery task workers. External dependencies include PostgreSQL, ClickHouse, Kafka, Redis, and cloud providers (GCP, AWS). The codebase also includes a billing/subscription layer (getsentry) and extensive third-party integrations (Slack, GitHub, Jira, etc.).
Vigil is a microservices status page application written in Rust. It monitors distributed infrastructure services via multiple probe modes (HTTP, TCP, SSH, ICMP, push, script, local), aggregates their health status, and serves a public status page with real-time updates. It also sends alerts through various channels (Slack, Email, Twilio, Telegram, etc.) when services go down or recover. The architecture is a single binary with separate threads for probing, aggregation, and HTTP serving, using a shared in-memory state protected by RwLock. The codebase is well-structured, with clear separation of concerns: config reader, prober, notifier, aggregator, and responder modules. It includes an MCP server for AI agent integration. The project is actively maintained with recent commits and CI/CD pipelines.
XCap is a cross-platform screen capture library written in Rust, supporting Linux (X11, Wayland), macOS, Windows, and HarmonyOS (OHOS). It provides a unified API for capturing images of monitors and windows, as well as video recording (currently work-in-progress). The library abstracts platform-specific implementations behind common `Monitor`, `Window`, and `VideoRecorder` structs, using native APIs such as XCB, PipeWire, CoreGraphics, AVFoundation, GDI, Windows Graphics Capture, and OHOS PixelMap. It is well-structured with clean error handling and modular platform modules, though some features like Wayland capture and window recording are still incomplete. The codebase demonstrates solid Rust engineering practices and is actively maintained.
LibreHardwareMonitor is a free, open-source hardware monitoring application for Windows (with partial Linux support) that reads temperatures, fan speeds, voltages, loads, clock speeds, and other sensor data from CPUs, GPUs, motherboards, storage devices, network adapters, power supplies, batteries, and various fan/water cooling controllers. The architecture is a Windows Forms desktop application (LibreHardwareMonitor.Windows.Forms) backed by a reusable .NET library (LibreHardwareMonitorLib) that abstracts hardware access through interfaces (IHardware, ISensor, IControl) and a visitor pattern for traversal. Key entry points include the MainForm UI, the Computer class that orchestrates hardware enumeration, and an embedded HTTP server providing REST/JSON and Prometheus endpoints. Data flows from low-level hardware interfaces (LPC I/O, MSR, SMN, SMBus, HID, NVAPI, ADL, WMI, IPMI, SMART) through sensor objects with min/max tracking and history compression, to the UI tree view, system tray icons, logging, and web clients. External dependencies include the Aga.Controls tree view library, HidSharp for USB HID, PawnIO kernel driver for low-level I/O, and several platform-specific native APIs. The codebase is large and well-structured with clear separation of concerns, but contains some monolithic files, outdated JavaScript libraries (jQuery 1.7.2, Knockout 2.1.0), and hardcoded hardware-specific mappings that require ongoing maintenance.
Monitorian is a Windows desktop application for adjusting brightness and contrast of multiple monitors via DDC/CI and Windows power settings. It features a WPF-based MVVM architecture with system tray integration, per-monitor sliders, and support for unison/adjustment modes. The application includes automatic startup registration, multi-language support (30+ languages), and a hidden diagnostic menu for probe/rescan/logging operations. Key components include custom slider controls (EnhancedSlider, CompoundSlider), window theming utilities (WindowPainter), and a robust settings persistence system using XML serialization. The codebase demonstrates solid engineering practices with clear separation of concerns, though it relies heavily on Windows-specific APIs which may require ongoing maintenance for OS compatibility.
MemReduct is a Windows desktop application for real-time memory monitoring and cleaning, implemented in C with the Win32 API and the undocumented Native API. It operates as a system tray utility that can manually or automatically purge various Windows memory caches: working sets, standby list, modified page list, system file cache, registry cache (Win8.1+), and combined memory lists (Win10+). The core cleaning logic uses NtSetSystemInformation with specific information classes, supplemented by volume cache flushing via the MOUNTMGR device. The application requires administrator privileges for full functionality and provides a configuration GUI with settings for auto-clean thresholds, intervals, hotkeys, language selection, and tray icon appearance. The architecture is monolithic: a single executable built from source files (main.c, main.h, resource files) that links against a reusable utility library (the 'routine' submodule). This library abstracts common Win32 tasks such as registry/INI config management, localization via .ini files, custom listview controls, theme handling, and device context operations. The application entry point is wWinMain in main.c, which creates the main dialog and processes window messages via DlgProc. Memory status is polled every second via a timer callback, and cleaning actions are triggered either manually through the UI or automatically based on user-defined thresholds. External dependencies are limited to Windows system DLLs (kernel32, user32, ntdll, advapi32) and the two submodules: 'routine' (utility code) and 'builder' (installer packaging). The build system uses Visual Studio 2017 project files with batch scripts for x86, x64, and ARM64 targets. No network dependencies exist except an optional update check. The codebase demonstrates non-obvious skill in low-level Windows system programming, custom GDI tray icon rendering, and conditional feature compilation, but remains maintainable through its separation of concerns in the routine library.
DuplexSpyCS is a full-featured Remote Access Trojan (RAT) command-and-control (C2) framework written in C# (.NET WinForms). It consists of a server-side management console and multiple payload variants (winClient48, winClient48DLL, Tipoff, etc.) that provide comprehensive post-exploitation capabilities: file manager, remote desktop, keylogger, webcam/microphone streaming, registry editor, process/task manager, remote shell (including xterm via WebView2), SOCKS5 proxy, and a plugin system for credential theft (Chrome, Edge, Firefox, MobaXterm). Communication uses a custom binary protocol (clsDSP) over TCP, TLS, or HTTP with RSA-AES hybrid encryption. The payloads employ persistence via registry/startup, UAC bypass, process injection (APC, EarlyBird, CreateRemoteThread, etc.), and fileless execution. The codebase is extensive but exhibits significant code duplication across payload projects, many incomplete or stub features, and outdated dependencies (AForge, NAudio, SharpPcap). It is explicitly designed for offensive security research and learning, but carries high risk of misuse.