htop is a cross-platform interactive process viewer and system monitor written in C on ncurses. It enumerates and displays processes by reading OS kernel interfaces — primarily /proc on Linux, sysctl/kvm/kstat on the BSDs and Solaris, libproc/mach on macOS, and PCP (Performance Co-Pilot) metrics for the pcp-htop variant — and renders a scrollable process table alongside a header of pluggable meters (CPU, memory, swap, disk I/O, network I/O, ZFS ARC, GPU utilization, pressure stall, battery, sensors, and more). Beyond display, it supports process management actions: kill, renice, set CPU affinity, scheduling and I/O priority, spawning strace/lsof child processes, plus tree view, sorting, filtering, incremental search, and persistent configuration in htoprc. Architecturally this is a monolithic C application with emulated object orientation: an Object base class with vtable-style Class function tables, generic containers (Hashtable with Robin Hood open addressing, Vector with ownership semantics), a RichString wide-character rendering layer, reusable Panel/Meter widget classes, and a ScreenManager event loop. Each supported OS lives in a backend directory (linux/, darwin/, freebsd/, openbsd/, netbsd/, dragonflybsd/, solaris/, pcp/, unsupported/) that implements the Platform/Machine/ProcessTable/Process contract. Entry points are htop.c and pcp-htop.c, which route through CommandLine_run() into ScreenManager_run(). The build uses GNU autotools with optional features (hwloc, libsensors, libnl, libcap, libunwind, PCP), and CI runs the binary headlessly under sanitizers plus a Lua/rote terminal-emulation test suite. Maintenance is genuinely active: recent commits, a CodeQL workflow, address/UB sanitizer jobs, valgrind suppressions, and a ChangeLog showing security fixes (CVE-2024-37676) and steady feature work through 3.6.0-dev. The honest caveats are platform fragility: Solaris and OpenBSD have TODO stubs for disk/network I/O, NetBSD uses deprecated proplib compatibility aliases, /proc and DRM fdinfo parsers are sensitive to kernel format changes, and there is visible copy-paste divergence across BSD backend field arrays. The core Linux path is current and well-maintained; the tail platforms lag, which keeps overall technical drift at medium rather than low.
Cursive is a mature, backend-agnostic TUI (Text User Interface) framework for Rust. It provides a rich set of composable widgets (dialogs, text views, edit views, select lists, progress bars, etc.), a flexible event system, full styling and theming support, and multiple backend implementations (crossterm, termion, ncurses, pancurses, BearLibTerminal). The architecture is split into `cursive-core` (backend-independent core) and `cursive` (user-facing crate with backends), plus `cursive-macros` for procedural macro support and `cursive-syntect` for syntax highlighting. The framework is designed for both simple scripts and complex real-time applications, with a focus on ease of use and composability. The core `View` trait defines layout, drawing, and event handling, while wrappers like `ViewWrapper`, `OnEventView`, `NamedView`, and `ResizedView` allow behavior composition without inheritance. The event system uses `EventTrigger` for declarative key binding and `Callback` for delayed actions. The style model supports gradients, palettes, effects, and TOML-based themes. The `Printer` abstraction handles coordinate transformations and styled drawing, and the `PrintBuffer` implements efficient double-buffering with diff-based output to minimize terminal writes. The builder module (experimental) enables declarative UI construction from YAML/JSON config files via a `Resolvable` trait and blueprint macros. The codebase is well-structured, extensively documented, and includes numerous examples and integration tests. It demonstrates strong software engineering practices: clean trait-based abstractions, thread-safe state via channels and `Arc`, efficient rendering, and modularity. While there is some code duplication across backends and a few deprecated items (e.g., `ScrollBase`), the overall quality is high and the library is actively maintained with a large user community.
Astroterm is a terminal-based star map application written in C. It renders the real-time positions of stars, planets, the Moon, and constellation figures using ASCII or Unicode characters. The system computes celestial positions from the Yale Bright Star Catalog, Keplerian orbital elements, and user-specified date/time and location (latitude/longitude or city name). It projects the visible sky onto the terminal via a stereographic projection and uses ncurses for display and input. The build system is Meson with Ninja, supporting Linux, macOS, and Windows. The codebase is well-structured into separate modules for astronomy calculations (astro.c), coordinate transforms (coord.c), terminal rendering (drawing.c, term.c), and data parsing (parse_BSC5.c, city.c). It includes comprehensive unit tests using Unity and CI via GitHub Actions. The application is highly configurable through command-line arguments and demonstrates strong craftsmanship in astronomical computations and terminal graphics.
rtorrent is a mature, high-performance BitTorrent client for Unix-like systems, built with ncurses for a terminal UI and supporting a wide range of features: DHT, PEX, encryption, magnet links, granular bandwidth throttling, and extensive scripting. It provides a rich command system that can be used interactively, via configuration files (`rtorrent.rc`), or remotely through SCGI, XMLRPC, and JSONRPC interfaces. Lua scripting is also supported for advanced automation. The architecture is modular and event-driven: the core handles download management, peer/tracker communication, and session persistence; the display layer manages ncurses windows and layouts; the input system processes keyboard events; and the RPC layer dispatches commands to the appropriate handlers. The codebase is well-organized into directories (`core/`, `display/`, `input/`, `rpc/`, `session/`, `ui/`, `utils/`) and uses a custom object system for command arguments and RPC values. The build system is Autotools with optional dependencies (e.g., Lua, XMLRPC backends). Key entry points include `src/main.cc`, `src/control.cc`, and `src/setup.cc`. The project is actively maintained with a strong CI pipeline (static analysis, unit tests, commit linting) and enforces modern C++20 standards. The code is generally clean but contains some manual memory management and legacy idioms; however, the overall engineering quality is high, with several reusable utility components.
Procmon-for-Linux is a Linux port of Microsoft's Sysinternals Process Monitor. It captures and displays system call events in real-time using eBPF raw tracepoints. The architecture is a modular C++17 application with four layers: tracer (eBPF-based), storage (SQLite), display (ncurses TUI or headless), and configuration/CLI. The main entry point is src/procmon.cpp which initializes the eBPF programs, parses command-line arguments, and runs either an interactive terminal UI or a headless collection mode. Data flows from kernel eBPF programs to a user-space consumer via a cancellable message queue, then into an SQLite in-memory database, and finally to the display layer. The application supports filtering, sorting, searching, and exporting events. It depends on the SysinternalsEBPF library for eBPF loading, libncursesw6 for UI, libelf for symbol resolution, and SQLite3 for storage. The eBPF kernel modules are version-specific and support Linux kernels 4.17 through 5.6+. The project includes mock engines for testing and builds packages for Debian and RPM-based distributions. The codebase demonstrates strong software engineering practices: clear separation of concerns, use of design patterns (factory, strategy, observer via queues), thread-safe event handling, and comprehensive testing with Catch2. However, it has some technical drift risks due to reliance on specific kernel versions, an older version of Easylogging++, and a custom SysinternalsEBPF library that may change. The build process is well-documented with dev containers and CI pipelines.
TuiCss is a CSS framework and JavaScript library that enables developers to build retro-style text-based user interfaces (TUI) for the web, mimicking the aesthetic of MS-DOS applications and Turbo Vision. It provides a comprehensive set of SCSS components including windows, panels, buttons, forms, tables, charts, modals, progress bars, and a responsive grid system, all styled with high-contrast colors and monospace fonts. The accompanying vanilla JavaScript adds interactivity for tabs, collapsible side navigation, modal dialogs, and live clock displays. The codebase is well-organized with modular SCSS files, a build pipeline using Gulp, and a clean separation of concerns. While the library has no automated tests, its examples demonstrate functional correctness, and the component structure supports straightforward reuse or theming via SCSS variables. The project is published on npm and has a small but active community with a healthy issue tracker.
tremc is a console-based client for the Transmission BitTorrent daemon that provides a curses interface for monitoring and controlling torrents. It connects to Transmission via its RPC protocol, offering features like torrent listing with sorting/filtering, detailed torrent views (files, peers, trackers), bandwidth control, and torrent management operations. The architecture follows a modular design with separate components for configuration handling, Transmission RPC communication, and the curses-based user interface. Key entry points include the main tremc executable and the ability to forward arguments to transmission-remote. The application maintains local caches of torrent state that are periodically updated from the daemon, with user interactions triggering RPC calls to control the daemon.
Notcurses is a C library for building rich terminal user interfaces (TUIs) with full pixel graphics, multimedia support, and a widget toolkit. It provides both a full-screen rendered mode and a direct mode for simple output. The library abstracts terminal capabilities (terminfo, escape sequences, pixel protocols like Sixel and Kitty) and offers a composable plane system with z-ordering, transparency, scrolling, and damage-based rendering. It includes built-in widgets such as reels, selectors, menus, progress bars, plots, trees, and tabbed containers, as well as a multimedia backend (FFmpeg/OpenImageIO) for image/video decoding and streaming. The architecture is centered around a core C library with official C++ and Python bindings, plus command-line tools (ncplayer, nctetris, notcurses-demo, notcurses-info, etc.) that demonstrate its capabilities. Input handling uses an automaton-based parser for escape sequences and mouse protocols. The codebase is substantial and well-tested, though some areas show incomplete features and platform-specific complexity.