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.
PMetal is a comprehensive machine learning framework specifically optimized for Apple Silicon hardware. It provides a complete suite for LLM training, fine-tuning, inference, and deployment through multiple interfaces (CLI, TUI, GUI, Python SDK, and REST API). The framework leverages Apple-specific technologies like Metal GPU, ANE, and UltraFusion for performance optimization while supporting standard ML workflows including LoRA/QLoRA fine-tuning, knowledge distillation, model merging, and quantization to formats like GGUF. The architecture follows a modular workspace design with over 20 specialized crates handling different aspects of the ML lifecycle, unified through a job specification system and configuration framework.
Mods is a CLI tool that pipes command output to large language models (LLMs) for AI-powered processing. It reads stdin, prepends a user prompt, sends the combined text to an LLM (OpenAI, Anthropic, Cohere, Google, Ollama, etc.), and streams the response to stdout. The architecture is a single Go binary using Bubble Tea for TUI (spinner, viewport) and a plugin-like provider system via the `internal/stream` interface. Key entry points are `main.go` (cobra CLI) and `mods.go` (Bubble Tea model). Data flows: stdin -> prompt assembly -> provider API call -> streaming output -> optional conversation caching (SQLite + gob files). External dependencies include multiple AI SDKs, Bubble Tea, Glamour for Markdown rendering, and SQLite for conversation storage. The repository is now archived as of March 2026, with the team focusing on a successor tool (Crush). Despite being archived, the codebase is well-structured, cleanly separated, and demonstrates strong Go engineering practices with a focus on testability and modularity.
This is a monorepo housing two terminal-based Instagram clients: a modern TypeScript client using React Ink for a rich Terminal User Interface (TUI) and a legacy Python client using curses. The system provides a full-featured Instagram experience entirely within the terminal, including real-time messaging via MQTT, feed and story browsing, profile viewing, multi-account management, authentication (with 2FA/challenge support), and one-turn CLI commands for AI agent integration. It also incorporates LLM-based chat summarization (OpenAI compatible) and basic analytics in the Python client. Architecture is straightforward: a CLI entry point (Pastel for TS, Typer for Python) dispatches commands, with the TUI built from reusable Ink components (ScrollView, MessageList, InputBox, etc.) that manage state via React hooks and contexts. A mock system enables offline UI development. External dependencies include reverse-engineered Instagram APIs (instagram-private-api, instagram_mqtt) and multiple utility libraries. The dual-client structure and reliance on patched, unofficial APIs introduce maintenance risks, but the TypeScript client is well-crafted with clear separation of concerns, thorough component reuse, and thoughtful UX design for keyboard-driven terminal use.
rclip is a command-line semantic photo search tool that indexes local image collections using a CLIP model (OpenCLIP ViT-B/32-256) and supports natural-language, image-to-image, and combined queries with boolean operations. The core architecture is monolithic: a Python package with modules for model inference (ONNX/CoreML), SQLite-based feature caching, image preprocessing, and a Textual terminal user interface for interactive browsing. It is fully offline and privacy-preserving, supporting a wide range of image formats including HEIC, raw (CR2, DNG, ARW), and standard web formats. The tool is distributed via PyPI, Snap, AppImage, Homebrew, and Windows MSI, with careful compliance management for third-party licenses, codecs, and model artifacts. It includes an extensive test suite (unit and end-to-end), CI/CD via GitHub Actions, and a compliance toolkit that enforces license policies during builds. The codebase is well-structured and demonstrates good engineering practices, though it relies on a pinned version of textual-image that uses a private API, introducing some technical drift risk.
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.
NetEase-MusicBox is a Python 3.10+ terminal client for NetEase Cloud Music (music.163.com), sold as the `musicbox` command. It is a hybrid application: an interactive curses TUI, an agent-facing stateless CLI, and a resident background daemon (`musicboxd`) that owns playback state. The TUI and daemon are mutually exclusive via a flock single-owner lock; control commands reach the daemon over a 0600-permission Unix domain socket using newline-delimited JSON-RPC. Audio plays through subprocess backends (mpg123 for MP3, mpv for FLAC/hi-res with IPC seek/volume control), and all NetEase API access goes through reverse-engineered weapi/eapi encryption (RSA+AES and AES-ECB with PKCS7/gzip handling). Login is QR-code scan only; session cookies and player state persist to XDG-compliant JSON/text files.
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.
octosuite is a Python command-line and interactive terminal (TUI) application for querying and analyzing public GitHub data. It provides a library interface for programmatic access and a CLI/TUI for interactive use. It wraps the GitHub REST API v3 with an in-memory cache and data sanitization. It supports users, organizations, repositories, and search. The codebase is well-structured with clear separation between API layer, models, CLI argument parsing, and TUI using questionary and rich. It is published on PyPI and uses modern Python packaging (uv). However, it lacks automated tests and does not handle GitHub API authentication or rate limiting, which limits its production readiness. The code is clean and follows good practices, making it a solid foundation for extension.
envio is a Rust CLI tool for managing environment variables in encrypted profiles. It creates, edits, imports, exports, and deletes profiles stored as `.envio` files in a project's `.envio/profiles` directory. The profiles can be plaintext or encrypted using passphrase (Argon2id + XChaCha20Poly1305), symmetric key (base64-encoded 32-byte key + XChaCha20Poly1305), or GPG (delegates to the system `gpg` CLI). The tool integrates with the OS keyring to store encryption keys and provides both a command-line interface and a TUI (beta) built with ratatui. The architecture cleanly separates library code (profile, cipher, env map) from binary code (CLI, TUI, prompts). The library is reusable for other Rust projects needing profile-based encrypted env management, though cipher types are somewhat coupled to the crate's error types. The encryption implementations demonstrate solid security practices (Argon2id password hashing, XChaCha20Poly1305 AEAD with streaming). The CI/CD pipeline builds for multiple platforms and generates shell completions and man pages at compile time. The project lacks unit tests in the visible source tree, which is a notable gap.
Jimmy is a command-line and terminal UI tool for converting notes from 50+ note-taking applications (Evernote, Obsidian, Joplin, Notion, Bear, etc.) into a unified Markdown format. It uses an intermediate representation (Notebook/Note/Resource/Tag objects) decoupled from input parsing and output writing, allowing clean extensibility. The architecture is a plugin-style converter framework with a rich set of format-specific parsers, markdown preprocessing libraries, and a resource deduplication system. The tool is distributed as standalone binaries bundling Pandoc and other dependencies. While the core abstractions are well-crafted, the vast majority of the codebase consists of tightly coupled format converters that are specific to each app's export schema, limiting general reuse. The project has extensive integration tests via a test data submodule, but many converters lack unit tests. Its requirement for Python 3.14 (a very recent version) and reliance on external binaries (Pandoc, one2html) introduce drift risks.
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.
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.
KIAUH (Klipper Installation And Update Helper) is a text-based user interface (TUI) and CLI tool for managing the Klipper 3D printer firmware ecosystem. It automates installation, update, removal, and backup of core components (Klipper, Moonraker, Mainsail, Fluidd, KlipperScreen, Crowsnest) and a wide range of community extensions (OctoPrint, Telegram Bot, Obico, Spoolman, etc.). The tool runs on Linux systems (primarily Raspberry Pi and similar SBCs) and handles systemd services, Python virtual environments, git repositories, nginx configuration, and system package management. Architecturally, KIAUH is a Python package with a modular design: a core framework provides menu navigation, logging, spinner animations, and a backend abstraction layer for command execution and filesystem operations. Components and extensions are implemented as classes inheriting from BaseExtension, each with install/update/remove methods. The tool supports multiple printer instances via an InstanceManager and uses a custom SimpleConfigParser for round-trip safe manipulation of Klipper-style configuration files. A headless CLI mode enables scripted, non-interactive operation. The codebase demonstrates solid engineering practices: dependency injection for testability, a plugin architecture for extensions, extensive test coverage (pytest with fake backends), and a well-organized package structure. Key reusable assets include the SimpleConfigParser (a standalone, comment-preserving config parser), the backend abstraction (enabling deterministic testing), and the BaseExtension plugin interface. While the tool is actively maintained and widely used, some areas show technical debt such as singleton proliferation, direct subprocess calls in places, and a Python 3.8 baseline that may limit future compatibility.
systemctl-tui is a terminal user interface for managing systemd services, written in Rust. It provides a fast, interactive alternative to the `systemctl` command-line tool, allowing users to browse, search, filter, and control systemd units (start/stop/restart/enable/mask/kill) and view live journal logs. The application supports both local operation and remote hosts over SSH, using D-Bus over a systemd-stdio-bridge connection on the remote side. Architecturally, the project is a Cargo workspace with three crates: `systemctl-ui-core` (shared library containing systemd D-Bus proxy, SSH helper, journal log parsing, formatting utilities, and a baked-in unit descriptions database), `systemctl-tui` (the main TUI binary built with ratatui, crossterm, and tokio), and `systemctl-gui` (an optional GTK4 frontend, not built by default). The TUI follows a single-component pattern with a large `Home` struct (~3000 lines) that implements a `Component` trait for initialization, event handling, and rendering. The event loop is asynchronous, with debounced journalctl calls and a spinner for service actions. Key features include fuzzy search, status filtering, context-sensitive action menus, a command palette, mouse support (drag to select log text), dark/light theme auto-detection, toast notifications for clipboard copies, and a pager for unit file editing. The project includes snapshot tests for the TUI, unit tests for core logic, and a comprehensive integration test matrix that runs against containers with systemd versions from 239 to current, as well as hostile hosts (no systemd).
Sup is a console-based email client written in Ruby, designed for heavy email users who prefer a keyboard-driven, terminal interface. It provides a Gmail-like workflow with thread-centric conversation view, labeling (tags), archiving, muting, and full-text search powered by Xapian. The application supports multiple local mail sources (mbox and Maildir), multiple accounts, and can be extended via Ruby hooks. It runs as a full-screen ncurses application with a buffer-based window manager, offering modes for inbox, search results, compose, reply, forward, and more. Architecturally, Sup follows a modular pattern with manager classes (PollManager, UpdateManager, UndoManager, DraftManager, etc.) that encapsulate state and behavior. The UI is built on a Mode hierarchy with a shared keymap DSL, allowing consistent keyboard navigation across different views. The core data flow involves polling mail sources, parsing messages with RMail, threading them using a JWZ-inspired algorithm, and indexing them into a Xapian database for fast search. Labels and state are persisted in YAML files and the Xapian index. Key entry points include the main `bin/sup` TUI, `bin/sup-sync` for index synchronization, `bin/sup-add` for adding sources, and various utility scripts. External dependencies include ncursesw, RMail, Xapian, GPGME, and Chronic for date parsing. The project is in maintenance mode, focusing on stability and bug fixes rather than new features, but remains actively maintained with CI across many Ruby versions.
Spiel is a terminal-based framework for creating and presenting slide decks using Python. It enables users to define slides as functions that return renderable objects (via Rich), and presents them in a navigable terminal user interface built with Textual. The framework supports features like live reloading during development, slide transitions, and dynamic content generation through a trigger system. The architecture centers around a `Deck` class that manages a sequence of `Slide` objects. Each slide's content is defined by a function that can optionally receive a `Triggers` object for time-based or interactive effects. The presentation is driven by a custom Textual application (`SpielApp`) that handles user input, screen transitions (including slide-to-slide animations), and automatic reloading of the deck when source files change. Key components include the CLI for launching presentations, a flexible slide definition system, and reusable widgets for rendering content such as syntax-highlighted code and images. Notable reusable components include the `Triggers` class for managing interactive state, the `Swipe` transition for slide animations, the `Image` widget for terminal image display, and a set of utility functions (`clamp`, `filter_join`, `chunks`) that solve common programming problems. These components are designed with low coupling and could be extracted for use in other projects with minimal modification.
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.
whatscli is a terminal-based (TUI) WhatsApp client written in Go. It connects via the WhatsApp Web API using the whatsmeow library, providing message sending/receiving, media attachment handling, group management, and desktop notifications. The architecture is a monolith with two goroutines: a tview-based UI main loop and a session manager that handles the WhatsApp connection and command dispatch through channels. The UI is highly configurable via an INI config file, supporting custom keybindings and color schemes. The codebase demonstrates good concurrency patterns with channel-based IPC and includes unit tests for the message storage layer. While the UI logic in main.go is tightly coupled to tview, the message database and event handling show clean separation and moderate reusability.
Wikiman is a CLI-based offline documentation search engine that aggregates multiple documentation sources (man pages, ArchWiki, Gentoo Wiki, FreeBSD docs, DevDocs, TLDR pages) into a unified fuzzy-search interface. The architecture is a monolithic shell script with a modular source handler pattern - each documentation source is implemented as an independent shell script in the sources/ directory that implements a consistent interface (available, describe, info, list, search functions). The main script (wikiman.sh) orchestrates parallel searches across sources, combines results, and presents them through a fuzzy finder (fzf/skim) with preview capability. Shell integration is provided via key-binding widgets for bash, fish, and zsh. The codebase demonstrates solid shell engineering practices: POSIX compatibility checks, clear function separation, proper error handling, and a clean extensible architecture for adding new documentation sources. The source module pattern is particularly well-designed - any new documentation source can be added by implementing the standard interface. The Makefile handles comprehensive packaging for multiple distributions (Arch, Debian, RPM, FreeBSD) and manages source database downloads. CI/CD pipelines automate package building and source database updates. The heavy reliance on awk for text processing is a double-edged sword - it enables powerful data manipulation in pure shell but creates maintenance complexity. The main script is monolithic (~500 lines) and could benefit from further modularization. However, the code is functional, well-structured, and demonstrates genuine craftsmanship in shell scripting.