wttr.in is a production-grade weather forecast service accessible via HTTP, designed primarily for terminal use with `curl`. It provides weather reports in multiple formats: ANSI-colored text (v1 and v2 views), plain text, JSON (j1/j2), Prometheus metrics (p1), HTML, and PNG images. The service automatically detects the user's location via IP geolocation (MaxMind GeoIP2) or explicit city/airport/coordinate queries, then fetches weather data from WorldWeatherOnline (the only actively configured data source). The architecture is a single Go binary with embedded assets (fonts, translations, templates) and a pipeline of interfaces: query parsing, location resolution, weather fetching, caching, rendering, and formatting. It supports 74 languages with per-language translation files and a rule-based routing system for selecting views and output types. The codebase demonstrates solid engineering with interface-based design, multiple caching layers (LRU in-memory, disk-based, SQLite-backed location cache), and request coalescing to prevent thundering herd on upstream APIs. However, it shows signs of technical drift: reliance on a single external weather API, hardcoded paths in configuration, disabled linters, and incomplete translations. The project is actively maintained with a large user base and extensive integration documentation for tools like tmux, Waybar, Emacs, and Google Sheets.
wthrr-the-weathercrab is a terminal-based weather companion written in Rust. It fetches current weather, hourly/daily/weekly forecasts, and historical data from the Open-Meteo API. The application supports configurable units, localization (via Google Translate API), and multiple display styles (border styles, graph types, color themes). It uses a modular architecture with clear separation of concerns: API abstraction, CLI argument parsing, configuration management, weather data fetching, and terminal rendering. The codebase demonstrates solid Rust practices including async/await, derive macros, and comprehensive testing. Notable features include a sophisticated Unicode graph renderer for temperature trends and a flexible localization system that can auto-translate strings. The project is actively maintained with recent commits and a responsive issue tracker.
This repository provides `claude-monitor`, a privacy-first CLI application for real-time monitoring of Claude Code usage. It reads local JSONL session logs, computes token consumption, costs, and burn rates, and displays them via a Rich-based terminal UI. The tool supports multiple subscription plans (Pro, Max5, Max20, Custom), integrates with Claude Code's official rate limits via statusline capture, and offers an opt-in persistent usage warehouse for historical analysis. It is distributed as a PyPI package with command aliases `cmonitor` and `ccm`. The architecture is modular, with separate packages for CLI, core logic, data ingestion/analysis, monitoring, output formatting, terminal management, UI components, and utilities. Key entry points include the CLI main module (`cli/main.py`), snapshot builder (`output/snapshots.py`), and monitoring orchestrator (`monitoring/orchestrator.py`). The application is well-tested with over 700 tests covering snapshot, trust-layer, warehouse, UI, timezone, and CLI paths. While primarily an application, it incorporates data engineering patterns such as sessionization, percentile-based limit estimation, and a versioned JSON warehouse. The codebase demonstrates strong craftsmanship with reusable components like the P90Calculator, PricingCalculator, TimezoneHandler, and UsageWarehouse. However, it has some technical drift risks due to hardcoded pricing rates, dependency on Claude Code's internal log format, and experimental API features that may change.
heh (HEx Helper) is a cross-platform terminal hex editor written in Rust. It provides a TUI for viewing and editing binary files in both hexadecimal and ASCII representations, with features like search (hex/ASCII), jump-to-byte, undo, clipboard integration, and configurable endianness. The architecture follows a clean separation of concerns: `app.rs` orchestrates state and event handling, `screen.rs` manages rendering via ratatui, `input.rs` dispatches keyboard/mouse events to pluggable `KeyHandler` implementations (editor, popups), and `buffer.rs` implements an asynchronous memory-mapped buffer for responsive editing of large files. The codebase demonstrates strong Rust practices, including use of traits for extensibility, iterator patterns for decoding, and a custom `OverlappingChunks` iterator for handling UTF-8 boundary issues. It is primarily an application but includes a library interface for embedding as a ratatui widget.
This is a Go library for console and terminal handling, part of the containerd project. It provides a cross-platform `Console` interface with methods for setting raw mode, resizing, disabling echo, and querying window size. The library supports Linux, macOS, FreeBSD, NetBSD, OpenBSD, Windows, and z/OS via build tags. On Linux, it includes an `Epoller` that uses edge-triggered epoll for efficient non-blocking I/O, handling EAGAIN/EIO errors gracefully. It can create PTY pairs (`NewPty`) and obtain the current process console (`Current`). The only external dependency is `golang.org/x/sys`. The code is idiomatic, well-tested, and follows Go best practices, though the dependency version and CI Go version are outdated.
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.
Gita is a CLI tool that manages multiple git repositories from a single command. It allows users to register repositories, organize them into groups, and perform batch git operations such as fetch, pull, status, and custom commands across all or selected repos. The tool also displays a side-by-side summary of repository states including branch, commit message, time, and status symbols for staged/unstaged/untracked changes and local-remote branch relationships. The architecture is a monolithic Python application with a clear separation of concerns: `__main__.py` defines the CLI interface via argparse and delegates to action functions; `utils.py` provides file I/O, configuration parsing, and async execution utilities; `info.py` contains all logic for gathering and formatting repo status information; `common.py` handles config file paths; and `io.py` parses clone configuration files. The tool uses subprocess and asyncio to run git commands concurrently for multiple repos, falling back to synchronous execution for interactive commands like difftool or when only one repo is targeted. Gita stores repository metadata in CSV files under `$XDG_CONFIG_HOME/gita/` and supports extensive customization via additional config files for colors, symbols, displayed info columns, and custom commands defined in JSON. The codebase is well-tested with pytest and exercised on CI across multiple Python versions and operating systems. While the core functionality is tightly integrated with its own config schema, several internal patterns (async subprocess execution, git status extraction via diff --quiet) are cleanly abstracted and could be repurposed in other git tooling with minor adaptation.
Term.jl is a Julia library for producing styled, beautiful terminal output. Inspired by Python's Rich library, it provides a markup language for inline color and style formatting (e.g., `{red}text{/red}`), a hierarchy of renderable objects (Panel, Table, Tree, Dendogram, ProgressBar), and interactive widgets (App, Menus, Pager, Buttons). The library also includes enhanced logging, stack trace rendering, progress bars, custom REPL display, and markdown rendering. Its architecture is modular: core types like `AbstractRenderable`, `Segment`, and `Measure` form the foundation, with composition via overloaded `*` (horizontal stack) and `/` (vertical stack) operators. A theme system centralizes styling. The codebase is well-tested with golden-file snapshots, but includes some platform-specific assumptions and absolute file paths in test fixtures that limit portability. Overall, it is a mature, feature-rich terminal UI toolkit with high craftsmanship.
TermUI is a comprehensive TypeScript monorepo providing a full-featured terminal UI framework for building rich, interactive command-line applications. It includes a custom JSX runtime with hooks, reconciliation, and portals; a theme engine (TSS) with CSS-like syntax and 26 built-in themes; a widget library spanning layout, input, display, data visualization, and feedback components; a motion system with spring physics and composable animations; a client-side router; a Zustand-like state store; adapters for external integrations (AI, Git, GitHub, clipboard, keychain); real-time system data hooks (CPU, memory, disk, Docker); a CLI scaffolding tool; and a dev server with hot reload. The framework is designed to offer a React-like development experience for terminal UIs, supporting JSX/TSX, keyboard and mouse input, focus management, accessibility (OSC 133), and unicode/ASCII fallbacks across 14+ packages with over 5000 tests.
google-images-download is a Python application for searching and downloading images from Google Images. It functions as both a command-line tool and a library that can be imported into other Python scripts. The system uses Selenium with Chrome to handle JavaScript-heavy Google Images pages, automatically manages chromedriver via webdriver-manager, and supports extensive filtering options (size, color, format, usage rights, etc.). Key features include filename sanitization for cross-platform compatibility, metadata extraction, similar image search, and robust error handling for network issues. The architecture is monolithic with a clear separation between argument parsing, URL building, browser automation, and download execution.
Gitlogue is a terminal-based Git history visualizer that replays commits as a cinematic typing animation with syntax highlighting. It loads a local Git repository, extracts diffs, and renders the changes character by character in a split-pane terminal interface (ratatui). The core architecture is a monolithic Rust binary using clap for CLI, git2 for Git operations, tree-sitter for syntax highlighting across 32 languages, and crossterm for terminal I/O. It supports multiple playback modes (random, chronological, watch) and includes a configuration system, 17 built-in themes, and a custom animation engine with step-based simulation and checkpoint/restore. Notable reusable components include the SelectableParagraph widget (isolated ratatui component for text selection and dimming) and the Theme system (extensible struct with ~40 named colors). The codebase is well-structured but exhibits moderate technical drift risk due to heavy tree-sitter dependency chain, rapid feature growth, and potential staleness with some language grammare updates. CI/CD is active but the release workflow is manual. Overall, gitlogue is a solid, professional terminal application that effectively delivers its claimed functionality.
Hermes Desktop is a native macOS desktop application that serves as a companion for the Hermes AI agent framework. It provides a rich GUI for managing remote Hermes instances over SSH or local connections, including session browsing (chat transcripts), a full terminal emulator (via the vendored SwiftTerm library), Kanban board management, cron job scheduling, file editing, skill browsing, usage analytics, and workflow presets. The architecture is a monolithic SwiftUI + AppKit app with a service layer that communicates with the remote host by generating and executing Python scripts over SSH, parsing JSON responses. The app is designed to be a direct client without any intermediate backend, treating the remote Hermes host as the sole source of truth. It includes a custom design system (HermesUI), localization support (en, zh-Hans, ru), and comprehensive test coverage. While the codebase is well-structured and demonstrates strong SwiftUI and macOS development practices, it has some monolithic views and relies on fragile embedded Python scripts for remote operations.
emacs-libvterm is a terminal emulator package for GNU Emacs, implemented as a hybrid of a C dynamic module and an Emacs Lisp package. The C module (vterm-module.c, elisp.c, utf8.c) wraps libvterm and exposes a small API (vterm--new, vterm--update, vterm--redraw, vterm--write-input, vterm--set-size, etc.) to Elisp. The Elisp side (vterm.el) provides the user-facing commands (vterm, vterm-other-window), manages the pty-backed shell process, defines keybindings, and implements copy mode, directory/prompt tracking, TRAMP support, and bookmarks. The module renders terminal cells into the Emacs buffer as text with font-lock face properties, batching runs of cells with identical attributes for performance. Data flows are bidirectional: keystrokes go from Emacs keybindings through vterm--update into the C term_process_key handler, which translates them into libvterm keyboard events and flushes resulting output bytes back to the pty. Shell output arrives via the process filter vterm--filter, which handles partial multibyte characters split across chunks, feeds bytes into libvterm, and triggers damage-based invalidation. The redraw pipeline (term_redraw, refresh_scrollback, refresh_screen, refresh_lines) maintains a scrollback ring buffer with per-line metadata (working directory, prompt column) that survives window resizes and reflow. OSC 51 escape sequences from the shell drive directory tracking, prompt detection, and whitelisted Elisp evaluation via vterm-eval-cmds. Notable engineering: the scrollback ring buffer with per-line metadata and resize handling, the batched cell rendering with text-property coalescing, and the clean separation between the Emacs API bridge (elisp.c) and terminal logic. The codebase carries compatibility shims for old libvterm versions (VTermStringFragment, VTermSelectionMask, sb_clear, reflow) and a dead Travis CI config targeting Emacs 25.3/26.1, indicating medium technical drift despite active maintenance. The term_process_key function is a monolithic if-else chain, and the CMake feature detection uses grep on headers, but overall the code is well-structured and battle-tested.
lsq is a CLI tool written in Go that serves as a lightning-fast companion for Logseq, the open-source knowledge base. Its core functionality is creating, appending to, and viewing daily journal entries directly from the terminal, following Logseq's file naming and formatting conventions (Markdown or Org-mode). The tool provides a rich set of flags for targeting specific dates, searching pages via a trie-based index (including alias support), regex searching across journals and pages, and piping content from STDIN. It also supports indentation for nested list items and a configuration file in EDN format for persistent settings. The architecture is a single-binary monolith with clear separation into config, system (file I/O, editor launch), trie, todo state cycling, and an EDN validator module. While the tool is tightly coupled to Logseq's directory structure (journals/ and pages/ folders), the underlying components like the trie search, file appending logic, and configuration loading are well-isolated and could be reused in other Go projects with minimal adaptation.
This repository is the canonical source of tldr-pages, a community-maintained collection of simplified man pages for command-line tools. It contains tens of thousands of Markdown files organized by language and platform, each providing concise usage examples for a CLI command. The repository also includes a suite of validation scripts, a build system for generating indexes and archives, and a client specification for consuming the pages. While primarily a documentation project, the tooling (Node.js and Python scripts) constitutes a small application layer that ensures consistency, quality, and automated releases. The repo supports translations in over 30 languages, with strict formatting and linting enforced by CI/CD pipelines. It is not a standalone application but the authoritative dataset and tooling for the tldr ecosystem.
This repository provides a comprehensive, self-contained tmux configuration known as 'Oh my tmux!'. It is a single `.tmux.conf` file with an embedded shell script that dynamically applies themes, key bindings, pane management, status line widgets (battery, uptime, load average, SSH-aware hostname/username), clipboard integration, and plugin management via tpm. The configuration is highly customizable through a separate `.tmux.conf.local` file. The code demonstrates advanced tmux scripting techniques, including conditional version checks, Unicode escape handling, and background processes for status updates. While the configuration is tightly coupled to tmux and not reusable as a standalone library, the shell functions for battery bars, uptime, and SSH detection exhibit high craftsmanship and could inform similar tmux configurations. The repository also includes an install script and detailed documentation.
YouPlot is a command-line tool for creating plots in the terminal using Unicode characters. It reads delimited data from stdin or files, parses it into headers and series, and generates various plot types (barplot, histogram, lineplot, scatter, density, boxplot, count) using the UnicodePlot backend. The tool follows Unix conventions, designed for use in data pipelines with options to pass through input data and output plots to stderr/stdout. It features progressive mode for real-time data visualization and supports configuration via CLI flags, config files, and sensible defaults.
spogo is a terminal-based Spotify client written in Go that provides full control over playback, library management, search, and user listening data. It authenticates via browser cookies (sp_dc/sp_t) instead of the official OAuth flow, allowing it to bypass rate limits by using Spotify's internal web API endpoints (Connect/GraphQL) alongside the public Web API. The architecture is modular with multiple engine backends (connect, web, auto, applescript) and a clean CLI interface built with Kong. It features robust output formatting (human, JSON, plain), comprehensive error handling with documented exit codes, and extensive test coverage. While the tool is highly functional and well-crafted, its reliance on undocumented internal Spotify APIs and webpack hash resolution introduces fragility that may require maintenance as Spotify's frontend evolves.
musikcube is a cross-platform, terminal-based music player and streaming server written in C++. It consists of a core library (`musikcore`) with a plugin-based architecture for decoders, encoders, audio outputs, DSP, and data streams. The project includes three distinct front-ends: a terminal UI (`musikcube`) built on a custom curses++ framework, a native Windows UI (`musikwin`) using a custom Win32 wrapper, and an Android remote client (`musikdroid`) written in Kotlin. The server plugin enables remote control and audio streaming via WebSocket and HTTP. The core manages a SQLite-backed music library with indexing, metadata extraction (via TagLib), and playlist management. Audio playback supports gapless and crossfade transitions, visualizers, and an equalizer. The system is designed for extensibility through a well-defined SDK interface set, allowing third-party plugins for decoders, outputs, and DSP. The codebase is mature (copyright 2004-2023) and shows signs of organic growth, with heavy vendored third-party dependencies and platform-specific code. While not architecturally pristine, it demonstrates solid engineering, a clean plugin API, and reusable UI frameworks.
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.