r3bl-open-core

██████╗  ██████╗  ██████╗
██╔══██╗██╔═══██╗██╔════╝
██████╔╝██║   ██║██║
██╔══██╗██║   ██║██║
██║  ██║╚██████╔╝╚██████╗
╚═╝  ╚═╝ ╚═════╝  ╚═════╝

Modernizing the Terminal: Taking Inspiration From Web and Desktop Apps

Despite the massive rise of AI/LLM coding agents & execution harnesses and cloud VM administration over SSH, terminal UI innovation has largely stagnated since the 1970s. Most CLI tools still rely on blocking single-threaded I/O, [curses]-era APIs, and fragile platform hacks - or rely on the heavy, fragile workaround of layering web stacks like [Node.js], [React], and [ink] onto the console. This introduces unreasonable memory bloat, high latency, broken keyboard shortcuts, and unpredictable instability that breaks down during long-horizon agentic workflows and sub-process orchestration.

ROC (r3bl-open-core) moves the terminal forward (with love & respect) into 2026 and beyond. ❤️

R3BL brings modern web and desktop app design patterns to the terminal, turning it into a place of focused productivity to build delightful, ergonomic, and rich text user interface (TUI) experiences.

Representing years of systems programming, performance optimization, and production-grade infrastructure design in Rust, R3BL re-imagines the terminal for the modern era - making rich, reactive TUI applications accessible over SSH to any terminal emulator across Linux, macOS, Windows, and Unix/BSDs (such as FreeBSD).

R3BL TUI is fundamentally different from [vim], [neovim], and [ratatui] through its immediate mode reactive UI, clean separation between rendering and state mutation, and purely async architecture - it never blocks the main thread, and natively embraces multithreaded execution and multi-process orchestration.

Primary Use Cases

ROC is designed to power four primary use cases:

• 🤖 AI/LLM Coding Agents & Execution Harnesses: Building fast, interactive terminal interfaces and execution harnesses for AI/LLM coding agents in pure Rust. While popular agent tools are written in [Node.js] and [ink] (see [origin story]), Node-based runtimes struggle with runaway memory consumption, fragile sub-process control, and unstable PTY session management when orchestrating heavy, long-running tools in sandboxed environments (containers, microVMs, systemd-nspawn machines, etc.). Furthermore, Node-based runtimes struggle with terminal input decoding, frequently dropping modifier keys, mangling keyboard chords, and introducing sluggish ESC key disambiguation lag. ROC provides a rock-solid, pure Rust foundation engineered for native PTY orchestration, zero-latency ANSI input decoding, deterministic process lifecycles, flicker-free diff rendering, and minimal resource overhead.

• ☁️ DevOps & Cloud Workflows: Administering modern cloud infrastructure shouldn't feel like using stone-age tools to build a satellite. Juggling remote VMs, containers, and multi-process server environments through bare terminal sessions is slow and error-prone. ROC transforms terminal workflows into a rich, responsive workspace with in-memory virtual terminal emulation, virtual tabs, 2D horizontal panning across wide logs, and double-buffered diff rendering that stays lag-free even over high-latency SSH connections.

• 📝 Interactive Document & Markdown Workflows: Rich interactive editing, syntax highlighting, and real-time code block execution directly inside Markdown documents in the terminal, bridging documentation directly with live operations.

• 🛠️ Developer Productivity Infrastructure: High-efficiency developer tooling and composable terminal infrastructure to enhance knowledge capture, eliminate friction, and streamline everyday command-line workflows.

The framework supports the full spectrum from CLI to inline dialogs to full-screen TUI and terminal multiplexing experiences with deep systems integration.

ROC Workspace Architecture: Core Engine, Productivity Apps & Build Tools

With over 2.7M downloads across crates.io, ROC (r3bl-open-core) provides production-grade systems infrastructure across five specialized crates:

Built-from-Scratch Primitives: The Four Pillars of r3bl_tui

At the heart of ROC is r3bl_tui, which provides four foundational interaction primitives designed from the ground up in pure Rust:

1. 📟 CLI & REPLs (readline_async): Unlike GNU [readline] which is single-threaded and blocking, our implementation is fully async, interruptable, and non-blocking, allowing background spinners and tasks to print concurrently without pausing line editing or blocking your main thread.

2. 📑 Inline / Partial TUI (choose): Single-shot interactive multi-select dialogs that enter raw mode and render inline in terminal scrollback without taking over the screen or disrupting the back buffer (similar to fzf in spirit).

3. 🖥️ Full-Screen TUI: Complete raw mode with alternate screen support, fully async and panic-safe terminal restoration. Build [React] and [Elm] inspired apps with [unidirectional data flow], [responsive] [flexbox] layouts, [declarative] [CSS-like] styling, reactive state architecture, reusable modal dialogs with asynchronous autocomplete, and a full-featured Markdown editor component with custom parser, custom syntax highlighter, and fast zero-copy gap buffer.

4. 🔀 Terminal Multiplexing & PTY: In-memory virtual terminals, virtual terminal tabs, deterministic process orchestration, and multiplexing primitives (build your own [tmux] or sandboxed AI/LLM coding agent execution harness) featuring 2D horizontal viewport panning and decoupled throughput.

Power via Composition: Designed to be [loosely coupled and strongly coherent], you can pick and choose only what you need or compose them seamlessly within a single application. Transition smoothly from a non-blocking readline_async prompt into an inline choose menu, launch a full-screen TUI for complex tasks, or orchestrate background PTY subprocesses, all sharing application state without process restarts.

Automated Headless Testing & Benchmarking

The entire framework across all 4 pillars is testable across Linux, macOS, and Windows. Powered by our own PTY pillar, real production code runs headlessly in an isolated virtual terminal environment, enabling end-to-end testing of interactive apps without requiring human interaction:

• PTY Automated Interactive Testing: Enables end-to-end testing of interactive apps via headless PTY subprocess orchestration with the generate_pty_test! macro. Automate key sequences, window resizing, and screen output verification in completely isolated child processes without someone having to sit and manually type at a keyboard.
• Visual UI Snapshot Testing: Everything renders to an offscreen buffer (OfsBuf), providing built-in visual snapshot testing. Easily diff and assert the actual rendered terminal screen state headlessly generated in a real PTY environment.
• Sans-IO In-Memory Terminal: Pure functional VT-100 parser verifying virtual terminal screen buffers directly in RAM with zero OS syscalls.
• Decoupled I/O Devices: InputDevice and OutputDevice abstract terminal I/O away from physical stdin and stdout, allowing input events and output streams to be driven and inspected directly in tests without taking over your terminal.
• Empirical Benchmarking & Flamegraph Profiling: Continuous performance measurement via Rust's built-in benchmarking suites and automated flamegraph profiling against established baselines rather than guesswork.

Engineered for Performance, Correctness & Reliability

• 📐 Zero-Cost Type-Proof Architecture & Mathematical Correctness: Rather than relying on ambiguous primitive integers (usize, u16) and runtime assertions, formal type theory and trait hierarchies [make illegal states unrepresentable]:
  • The Newtype Pattern for Domain Separation & Coordinate Safety: Replaces raw primitive integers with zero-cost newtypes (CRow, VPRow, CHeight), eliminating primitive obsession and transposition bugs with zero runtime memory or performance overhead:
    • 0-Index vs 1-Index Separation: Strongly types the distinction between 0-based buffer positions (IndexOps: VPRow, VPCol, CRow, CCol), 1-based terminal coordinates (TermRow, TermCol), and 1-based lengths (LengthOps: VPHeight,