Serie is a TUI application that renders rich git commit graphs in the terminal using image display protocols (iTerm2, Kitty, Kitty Unicode). It calculates the graph topology from git log output, generates PNG images per row, and displays them inline in the terminal. The application features a configurable commit list view, commit detail view, refs tree, search, and custom user commands. Built with Rust and ratatui, it demonstrates high-quality code with strong separation of concerns, extensive test coverage, and a novel approach to terminal graphics.
Codewhale is an open-source, terminal-native AI coding agent that operates as a TUI (ratatui), CLI, headless runtime, MCP server, and a web frontend. It manages full development workflows: reading repositories, editing files, running commands, reviewing changes, and orchestrating multi-agent fleets. The codebase is a Rust monorepo with ~52 crates, a Next.js website with 18+ locales, a VS Code extension, packaging for npm/Homebrew/Arch/Windows, and companion pet apps. The architecture is event-driven with a pluggable tool system, model-agnostic provider routing, session-based journaling, and a contract-based command framework. It supports dozens of LLM providers (DeepSeek, OpenAI, Anthropic, Ollama, etc.) and features sandboxed execution, telemetry with a strict no-IP privacy contract, and a plugin marketplace. The project is heavily tested with unit, integration, PTY/Cucumber, and hermetic bash tests, and enforces budgets for dead code and blocking calls.
RustNet is a cross-platform, real-time network monitoring terminal UI application. It captures packets via libpcap (or platform-specific backends like PKTAP on macOS, ETW on Windows), performs deep packet inspection (DPI) for protocols including HTTP, HTTPS, DNS, SSH, QUIC, BitTorrent, and many others, and attributes each connection to the owning OS process using eBPF (Linux), lsof (macOS), IP Helper (Windows), or sockstat (FreeBSD). The architecture is a multi-crate Rust workspace: `rustnet-core` provides connection tracking, DPI analyzers, GeoIP/OUI lookup, and rate/RTT tracking; `rustnet-capture` wraps libpcap; `rustnet-host` implements process lookup via a unified `ProcessLookup` trait; `rustnet-sandbox` handles privilege dropping and sandboxing (Landlock, Seatbelt, Windows job objects). The main binary (`rustnet-monitor`) orchestrates capture, enrichment, and a ratatui-based TUI with tabs for Overview, Details, Activity, Graph, and Host. It supports PCAP/PCAPNG export with process metadata, JSONL event logging, Kubernetes pod attribution, and a rich theme system with multiple presets. The codebase is well-structured, extensively tested, and actively maintained with CI/CD for multiple platforms and packaging (DEB, RPM, DMG, MSI, Homebrew, Chocolatey).
gitlogue is a terminal-based Git commit visualization tool that animates repository history as a cinematic typing experience. It replays commits with realistic character-by-character typing animations, syntax highlighting via tree-sitter, and dynamic UI panes showing file trees, editor views, and terminal output. The application is built in Rust using ratatui for terminal rendering, git2 for repository access, and features a modular architecture with separate concerns for Git processing, animation engine, theme management, and UI components. Key features include commit filtering, configurable playback speed, screensaver mode, and 16 built-in color themes.
nixos-wizard is a terminal-based NixOS installer that provides a text-based UI for guided system installation. It follows a modular architecture with an event loop managing UI state, Page and ConfigWidget traits for UI components, and an Installer struct as central data store. The application guides users through configuration steps including disk partitioning, user creation, package selection, and system settings, then generates NixOS configuration files (configuration.nix and disko config) for installation. Key features include interactive disk partitioning powered by Disko, real-time package search with fuzzy matching, and immediate validation of generated configurations.
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.
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.
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).