SenPaiScanner is a production-grade Cloudflare IP scanner with three frontends—a Bubble Tea TUI, a Wails v2 desktop GUI, and an Android Kotlin/Compose app—all sharing a common Go core. It scans Cloudflare's IPv4 ranges to discover reachable endpoints for VLESS/Trojan/VMess proxy configurations on filtered or high-latency networks. Scans run in two phases: a fast TCP/TLS/HTTP connectivity sweep, followed by optional validation through an embedded xray-core instance that measures latency, loss, jitter, and throughput. Results can be exported as raw endpoints, rewritten share URLs, Base64 subscriptions, Sing-box JSON, and Clash YAML, with live file output during scanning.
NetworkManager is the standard Linux network management daemon, providing D-Bus and file-based APIs to control network interfaces, connections, VPNs, and system-wide DNS. The architecture is a modular system daemon (`NetworkManager`) with a rich GObject-based client library (`libnm`), a command-line tool (`nmcli`), a text UI (`nmtui`), and an initrd generator for early-boot networking. The daemon manages Ethernet, Wi-Fi (via wpa_supplicant or IWD), Bluetooth, WWAN (ModemManager), VLANs, bonds, bridges, VXLAN, WireGuard, and many other device types through a pluggable device model. Configuration is stored in keyfile format (or legacy ifcfg-rh). The codebase integrates heavily with systemd (sd-event, sd-device, DHCP6 stack) and bundles several high-quality low-level C libraries (c-list, c-rbtree, c-siphash, n-acd, n-dhcp4) for performance and correctness. While the project is mature and actively maintained, it carries technical debt from deprecated subsystems (WiMAX, ifcfg-rh) and a large vendored systemd core that requires periodic upstream synchronization. Overall, it is a masterclass in large-scale system C programming using GLib, D-Bus, and modern Linux APIs.
UmaDev is an AI-powered development agent that orchestrates multiple first-class AI coding CLIs (Claude Code, Codex, Grok Build, Kimi Code, OpenCode) as subprocesses, providing a unified terminal UI, governance, knowledge retrieval, and a spec-driven pipeline. It acts as a 'project manager' for AI coding agents, handling planning, execution, review, and acceptance. The architecture is a multi-crate Rust workspace with a TUI (ratatui), agent orchestration, governance engine, knowledge retrieval (BM25 + optional local embeddings), contract validation, and cross-platform process management. It is distributed via npm with platform-specific binaries. The codebase demonstrates high craftsmanship with pervasive fail-open patterns, bounded resource usage, and extensive testing. Key subsystems include a deterministic governance engine with 113 content checks, a hybrid retrieval system with CJK-aware tokenization, a cross-process run lock with boot-id liveness, and a host-owned Git commit transaction with rollback. While primarily an application, it includes a curated knowledge corpus (~400 markdown files) and an offline embedding model, giving it a hybrid character. The repository is actively maintained with a clear release pipeline and CI/CD. Notable design patterns include: fail-open governance (every check wrapped in catch_unwind), bounded file system operations (RootedDir with no-follow, size limits), circuit breaker for compaction, and source tree fingerprinting for freshness. The codebase is well-structured with clear separation of concerns across 11 crates, though some files are large hotspots (e.g., app.rs, director_loop.rs). Overall, it is a sophisticated, production-quality tool for AI-assisted software development.
Lazydocker is a mature, well-structured terminal UI application for managing Docker and Docker Compose environments. Built in Go using a forked version of the gocui library, it provides a unified interface for viewing containers, services, images, volumes, and networks with real-time monitoring, log streaming, and interactive command execution. The architecture follows a clean separation between the command layer (Docker API interactions, OS command execution), presentation layer (display string formatting), and GUI layer (gocui-based terminal interface with panels and keybindings). The codebase demonstrates solid engineering practices with a generic, thread-safe FilteredList data structure that efficiently handles filtering and sorting without modifying underlying data. The task management system supports cancellable, concurrent operations with proper context propagation. The SSH tunneling implementation for remote Docker hosts is particularly well-crafted, using dependency injection for testability. The project maintains active development with recent commits, comprehensive CI/CD across multiple platforms, and support for 9 languages. Key architectural patterns include a panel-based UI composition where each side panel (containers, services, images, etc.) shares common infrastructure through generic types, a context-aware main panel that re-renders based on selected items, and a flexible template system for The configuration system supports extensive customization while maintaining sensible defaults. The codebase uses vendored dependencies for reproducible builds and includes proper error handling with user-friendly error messages.
torlink is a terminal-based torrent client that combines a rich Text User Interface (TUI) with headless daemon modes for torrent search, download, seeding, and file serving. Built with TypeScript, Node.js, and React (via Ink for TUI rendering), it provides zero-configuration access to curated torrent sources across categories like games, movies, TV, and anime. The application features parallel source querying, result deduplication, automatic seeding with optional file deletion, and persistent state management for queues, history, and seeds. The architecture follows a modular design: the TUI layer (src/ui) handles interactive modes, daemon services (src/daemon) manage headless operations (serve, files, watch, seed, attach), core download logic (src/download) manages the torrent queue and engine integration, and source plugins (src/sources) fetch torrents via RSS, APIs, or web scraping. Key utilities include atomic file writes, resilient HTTP fetching, caching, and format helpers. The CLI entry point (scripts/cli-entry.cjs) handles Node version checks and WebRTC fallbacks before launching the appropriate mode. External dependencies include Ink for TUI rendering, webtorrent for torrent handling, node-datachannel for WebRTC fallbacks, and various HTTP clients. The project maintains active development with recent commits, comprehensive test coverage, and CI workflows. While dependency pinning indicates managed compatibility risks, the codebase demonstrates strong engineering practices through isolated utilities, reactive patterns for concurrent searches, and cross-platform path handling.
ov is a feature-rich terminal pager written in Go, designed as a modern replacement for less/more. It supports large files via chunked reading with memory limits, ANSI escape sequence rendering, column alignment, word wrapping, search (case-insensitive, regex), follow/watch modes, multiple documents, sidebar panels (help, marks, doc list, sections, styles), mouse support, and extensive keybinding customization. The architecture is a single binary with a core `oviewer` package handling document management, screen drawing, event processing, and input modes. It uses `tcell` for terminal UI, `cobra` for CLI, `viper` for configuration, and supports compressed files (gzip, bzip2, zstd, lz4, xz). The codebase is well-tested with over 100 test files and demonstrates solid engineering practices including reusable patterns for bidirectional maps, ordered maps, converters, and input handling.
SimUtil is a Dart-based terminal UI/CLI for managing iOS simulators and Xcode Derived Data. It wraps `xcrun simctl` to list, boot, shut down, install, launch, and interact with simulator devices, and adds conveniences like showing/cleaning Derived Data. The app is operated entirely from the terminal and stores user preferences in `~/.simutil/settings.yaml`, including a `plugins:` section for custom commands. Architecturally it separates terminal UI components (`lib/components`) from services (`lib/services`) such as `CommandExec` (a shell-command abstraction), `UserConfig` (YAML settings with first-run defaults and scalar merge), and Derived Data helpers. A `tool/generate_changelog.dart` code generator parses `CHANGELOG.md` and emits typed Dart data so the app can show post-update changelog dialogs. Tests cover the changelog generator and config file behavior, and CI runs build/install verification across platforms.
Matcha is a full-featured terminal email client (TUI) written in Go, using the Bubble Tea framework. It supports multiple email protocols (IMAP, JMAP, POP3, Maildir) and provides a rich set of features including PGP/SMIME encryption, OAuth2 authentication, a Lua plugin system with 35+ community plugins, background daemon for push notifications and sync, spellcheck, i18n with 11 languages, and a configurable theme system. The architecture is modular: a backend provider interface abstracts protocol implementations, a daemon runs as a background process communicating via JSON-RPC over Unix sockets, and the TUI is built with composable Bubble Tea models. The codebase demonstrates strong engineering practices with extensive test coverage, CI/CD pipelines, cross-platform packaging (Homebrew, Snap, Flatpak, Nix, WinGet), and a well-designed plugin API. It is not a data research project; it is a production-grade application.
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.
cli-chess is a terminal-based chess application that supports playing online via Lichess.org and offline against the Fairy-Stockfish engine. It features a modular MVP (Model-View-Presenter) architecture with clear separation of concerns across core game logic, reusable UI components (board, move list, chat, clock), menu systems, and API integration. The application supports all Lichess chess variants, includes features like premoves, takebacks, draw offers, chat, blindfold mode, unicode pieces, custom theming, and PGN export. Entry point is src/cli_chess/__main__.py, with gameplay driven by user input flowing through presenters to models, which update views via an event system. External dependencies include python-chess for board logic, berserk for Lichess API, and prompt-toolkit for the terminal UI.
This is a Rust CLI tool called `facts` that implements a fact-driven development workflow. It manages a `.facts` file containing atomic, verifiable claims about a project, each with lifecycle tags (`@draft` → `@spec` → `@implemented`) and optional shell commands for automated verification. The tool provides a rich set of subcommands for listing, adding, editing, removing, linting, and checking facts, along with a terminal UI (TUI) built with Ratatui and Crossterm. It integrates with AI coding agents (Claude, Codex) to verify manual facts via an XML-based verdict protocol, and ships with bundled agent skills for discovery, refinement, and implementation. The project is self-hosting—it uses its own `.facts` file to describe itself—and is distributed via npm, PyPI, and direct install. The architecture is a monolith with clearly separated modules for parsing, writing, ID generation, tag filtering, file locking, and agent communication. The codebase demonstrates strong engineering practices: deterministic round-trip serialization, atomic file writes, advisory locking with stale detection, and a boolean expression evaluator for tag filters. It is actively maintained with a comprehensive test suite and CI/CD pipeline.
Go Blueprint is a CLI tool for scaffolding Go project structures with optional integration of popular web frameworks (Chi, Gin, Fiber, Echo, Gorilla, HttpRouter, standard library), database drivers (MySQL, Postgres, SQLite, Mongo, Redis, Scylla), and advanced features (HTMX/Templ, Tailwind CSS, React/Vite, WebSocket, Docker, CI/CD workflows). The tool operates both interactively (via a TUI built with Bubble Tea) and non-interactively via command-line flags. It generates a complete project skeleton including `go.mod`, `Makefile`, `.air.toml`, `.env`, server code, routes, tests, and Docker configuration. The architecture is a standard CLI application using Cobra, with a clear separation of concerns: flags parsing, UI components, template generation, and project file creation. The codebase is well-structured, modular, and includes comprehensive CI/CD pipelines (linting, integration tests via Testcontainers, release automation). It is a practical, production-ready tool for Go developers.
libvaxis is a terminal user interface (TUI) library for Zig that provides both low-level terminal manipulation and a high-level declarative widget system (vxfw). The library does not rely on terminfo; instead it dynamically queries terminal capabilities via escape sequences, supporting modern features such as RGB color, kitty keyboard and graphics protocols, hyperlinks (OSC 8), bracketed paste, mouse shapes, system clipboard, notifications, synchronized output, and Unicode Core. The architecture comprises an event-driven loop (generic over event type) that reads from a platform-specific TTY abstraction, a state-machine parser for input sequences, double-buffered screen rendering with diff-based updates, and a widget tree with constraint-based layout, focus management, and event propagation (capture/target/bubble phases). Low-level components include the TTY abstraction (Posix, Windows, test stub), input parser, screen buffer, window sub-region handling, and image transmission via the kitty graphics protocol. The high-level vxfw framework offers composable widgets such as Button, TextInput, ListView, SplitView, Border, FlexRow/Column, ScrollView, Spinner, and more. Widgets receive draw context with min/max constraints and an arena allocator per frame, returning surfaces that may contain child surfaces. The library also includes an embedded terminal emulator widget (Terminal) that runs a child process in a PTY and renders its output as a virtual terminal. A stable C API is provided via `vaxis.h`, exposing parsing, screen manipulation, and runtime management without requiring Zig compilation. Cross-platform support covers macOS, Windows, Linux and BSD/Unix systems. The library is built with Zig 0.16.0 and depends on `zigimg` for image decoding and `uucode` for Unicode property data, both fetched as build dependencies.
picosnitch is a Linux daemon for per-executable network bandwidth monitoring using eBPF (CO-RE) and fanotify. It tracks which executables make network connections, records bytes sent/received, timestamps, and metadata (SHA256 hashes, optional VirusTotal and GeoIP lookups). The system provides real-time and historical views via multiple interfaces: a curses TUI (both live top and historical browser), a web UI, and a UNIX socket live feed. The daemon uses a multiprocess architecture with privilege-separated subprocesses for monitoring, event processing, database writes, notifications, and external API queries. It supports local SQLite storage and optional remote SQL (MariaDB/MySQL/PostgreSQL) for tamper-evident logging. The repository also includes a comprehensive comparative benchmark suite (bench/) that tests picosnitch against nine other network monitors across 24 scenarios, with a reusable ToolAdapter framework for running controlled experiments.
oq is a terminal-based OpenAPI Specification viewer that allows users to visualize and navigate OpenAPI 3.0, 3.1, and 3.2 specifications in JSON or YAML format. The application reads OpenAPI specs from files or stdin, parses them using the libopenapi library, and presents the information in an interactive terminal UI with views for endpoints, components, and webhooks. Users can navigate using keyboard shortcuts, fold/unfold sections to see details, and cycle between different views. The architecture separates OpenAPI processing logic (in oas.go) from the terminal UI (built with bubbletea), demonstrating good separation of concerns.
MD-TUI is a Rust-based terminal markdown viewer (TUI) that renders `.md` files with full keyboard navigation, syntax highlighting via tree-sitter, inline images, foldable `<details>` blocks, mermaid diagrams, table rendering, search, and link following (internal/external/wiki). It can be used as a standalone binary (`mdt`) or as a library. The architecture is monolithic but modular: a custom PEG parser (`src/md.pest`) converts markdown into a component tree (`ComponentRoot`) composed of `TextComponent` and `ImageComponent` nodes; these are rendered to the terminal using `ratatui`. Configuration is loaded from `~/.config/mdt/config.toml` or environment variables. The repository demonstrates strong Rust craftsmanship with well-separated modules, optional feature flags (`tree-sitter`, `network`), thread-local caching for syntax highlighting, and a comprehensive test suite covering parsing edge cases, search, and rendering behavior.
tui-realm is a Rust library/framework for building terminal user interfaces (TUIs) using a component-based, event-driven architecture. It is not a standalone application but a reusable framework that wraps ratatui (formerly tui-rs) and provides an Application loop, Component/AppComponent traits, a Model/Update/View pattern, and a subscription system for routing events between components. The monorepo is organized as a Cargo workspace containing the core `tuirealm` crate, a `tuirealm_derive` procedural macro crate, a standard library of reusable components (`tui-realm-stdlib`: Input, Label, List, Table, etc.), and optional integration crates `tui-realm-textarea` and `tui-realm-treeview`. The framework is designed to reduce boilerplate by centralizing focus management, event routing, and state handling in the Application/View layer, while allowing developers to define custom components and event sources via Ports and Subscriptions.
Crawlkit is a shared Go library and CLI tool (crawlctl) for building local-first crawler archives. It provides provider-neutral building blocks including SQLite stores with FTS5, snapshot/export to gzipped JSONL shards, Git-based mirroring with immutable tags, encrypted backup with age/gzip and SHA-256 deduplication, sync state management with legacy adapters, vector search (exact cosine similarity and optional turbovec Python bridge), embedding providers (OpenAI, Ollama, llama.cpp), a terminal UI (Bubble Tea) for browsing archive rows, and a remote archive client for Cloudflare Workers. The CLI discovers installed crawl apps (e.g., gitcrawl, discrawl) and runs configured refresh jobs under a single-process lock. The architecture is modular and composable, with clear ownership boundaries documented in docs/boundary.md. The repository also includes agent skills (autoreview, crabbox) for automated code review and remote validation, reflecting heavy agent-driven development. It is not a generic web crawler but a mechanics layer that makes each crawl app smaller and more uniform.
This is a monorepo for 'pi', an AI coding assistant platform. The repository contains multiple packages including a coding agent with a terminal UI (TUI), multi-provider AI integration (OpenAI, Anthropic, Google, Bedrock, Mistral, xAI, and more), a durable execution framework for conversation persistence, a protocol layer with strict CBOR encoding, and telemetry infrastructure. The coding agent supports interactive mode with session management, tool orchestration, subagents, and MCP (Model Context Protocol) integration. The architecture is a TypeScript monorepo using npm workspaces with packages for AI providers, coding agent, durable execution, protocol, telemetry, and TUI components. The AI package provides a unified interface across multiple providers with OAuth flows, model catalogs, and streaming support. The coding agent implements a TUI with themes, keybindings, and interactive components. The durable package provides event-sourced storage with SQLite and JSONL backends, session management, and compaction. The repository also includes evaluation infrastructure (Docker-based evals), benchmarks for storage and delta traversal, and telemetry for usage tracking. The codebase demonstrates strong engineering practices with clean abstractions, reusable components, and comprehensive test coverage, though some areas (durable harness, experimental services) are still evolving.
Proxelar is a high-performance, scriptable local traffic workbench for HTTP, HTTPS, and WebSocket debugging. It functions as a man-in-the-middle (MITM) proxy that can capture, inspect, intercept, modify, replay, and export traffic across multiple protocols (HTTP/1.1, HTTP/2, HTTP/3, WebSocket, SOCKS5, DNS, UDP, and WireGuard). The system is built as a Rust workspace with four crates: `proxelar-cli` (binary with TUI, terminal, and web GUI interfaces), `proxyapi` (core proxy engine with TLS interception, Lua scripting, addon system, route rules, and session export/import), `proxelar-proto` (transport-neutral HTTP core with sans-I/O parsers for HTTP/1 and HTTP/2), and `proxyapi_models` (shared data types for headers, sessions, and captured exchanges). It supports forward and reverse proxy modes, declarative JSON routing rules, Lua addons with SHA-256 verification, and exports to HAR, curl, and raw formats. The architecture is modular with clean dependency direction, extensive integration tests, performance benchmarks, and property-based testing. It is a production-quality developer tool comparable to mitmproxy or Charles Proxy, with a focus on performance, correctness, and extensibility.