// ARB — A TUI FOR EVERY PIPELINE

What it is

arb turns a pipe into an interface. Drop it into a pipeline — find / | arb — and instead of scrolling past text you get a live view of the stream. The full language lets a small declarative spec describe widgets, layout, a uniform query over any format, and interactive controls that feed back into the passthrough, so arb can shape the downstream output mid-pipe, not just display it.

It is an original language in stryke's class — not a port. It reuses mechanics from its siblings (fusevm embedding, the rkyv bytecode cache, the LSP/DAP stdio shape, the package-manager ABI) but the lexer, parser, AST, lowering, and semantics are arb's own. Standalone crate, MIT, deliberately lean — rubyrs-scale, not stryke-scale.

The world-first: synthesis + ecosystem

No single leg is new — Tcl/Tk (1988), Expect (1990), dasel (unified query), ratatui (TUI), Streamlit / textual serve (served web UI) are all prior art. arb's novelty is the combination: a pipe-native, dual-target (terminal + web), component-generating UI language with a shareable dashboard registry. There is no registry of installable pipeline TUIs today — cmd | arb sniffs the upstream command or data shape, resolves the matching arb-<tool> package, and renders. Every common pipeline (docker / kubectl / psql / nginx / git / systemctl) gets a shared, installable dashboard.

Try it

With no spec, arb synthesizes a full-screen tail of stdin — the zero-config path. With a spec (a .arb file or an -e one-liner) the interpreter reads the declarative language — widgets, source/out query pipelines, controls, reactions, and .x <- in binds — and renders it. With no controlling terminal on stdout (piped onward / redirected / CI) arb prints the parsed spec and each source's evaluated result instead of a TUI.

cargo install --path .

# zero-config: a live tail with count + rate; q / Esc / Ctrl-C quits
find / | arb

# a spec: a gauge fed by the live line count of the stream
seq 1 100000 | arb -e 'gauge .g -max 100000; source .g { in; count }'

# a filtered list: keep 5xx lines, drop health checks
tail -f access.log | arb -e 'list .l; source .l { in; match /5\d\d/; reject /health/ }'

arb today is a full query engine — a jq/xpath/css/yq superset, ~90 verbs over line, JSON, CSV/TSV, YAML, TOML, and HTML — with an expression layer (where/map/ternary) whose arithmetic lowers to fusevm bytecode, rendering into the full ratatui data-widget set — text/tail/list/gauge/linegauge/bars/histo/spark/sparkline/scatter/chart/map/calendar/table widgets, plus a scrollbar on overflowing lists (each -color themeable). It is interactive: the megafilter/map (type or bind a transform and the piped output reshapes live via input/apply/out), a fuzzy select mode (fzf as a one-widget spec), a sel selection list whose highlighted row is published as .<path>.sel, and stream reactions (expect /re/ → action). It also serves the same spec as a live browser dashboard (arb --serve, WebSocket push with a polling fallback) and ships a package manager (--install/--uninstall/--installed) to share dashboard specs. Akka-style actors ship (SPEC §15): actor NAME(state) { on MSG { … reply EXPR } } declarations backed by a real mpsc-mailbox thread-per-actor runtime (tell/ask/supervised pool), with two surfaces: a via NAME * N pipeline op that fans the stream across a worker pool in parallel, and session refs (spawn/pool + supervise) driven by tell/ask bind/expect actions in the TUI. Dashboards lay out on a proportional grid (rows "1 2 1"/cols "20c * 2*" fixed/percentage/weighted tracks, gap, layout horizontal), and a color-theme system of 31 palettes ported from the sibling iftoprs/htoprs apps (plus theme custom c1..c6) is always on — default neon-sprawl, set globally with arb --set-theme (~/.arb/config.toml) or per-run --theme, recoloring the whole TUI and the fzf picker from the palette. Inline rust { … } FFI blocks compile to a cached cdylib callable from expressions. Nothing is faked — unrecognized widget verbs are ignored so specs stay forward-compatible, and unbuilt features are absent, not stubbed.

The language (specified)

arb's syntax is Tcl/Tk-flavored but is not Tcl — no $ substitution, no [cmd] substitution, no expr{}. Commands take args and verbatim { } blocks; widget paths are dot-hierarchical (.a.b.c), Tk-style. Variables are Python/Swift-lite (max = 100 immutable, var n = 0 mutable). The full grammar is in SPEC.md.

tail  .log  -label "requests"
table .t    -cols {ts level msg}
gauge .cpu  -label "cpu %" -max 100

source .t { in.json; each; where(is5xx); count; every 1s }
.cpu <- cpu_pct

filter .q                        # text box  -> .q
facet  .lv -field level          # facets    -> .lv selected set

out {
    where(match(.q))             # filter by the text box
    where(level in .lv)          # filter by facet selection
    map(x => pick(x, {ts msg}))  # MAP the passthrough, not just filter
}

Query — one engine over every format

A single query vocabulary works uniformly over JSON, XML, HTML, YAML, TOML, and CSV — a jq/xpath/css/yq superset.

Milestones

arb landed in stages; the table reflects the current tree. The query engine, expression layer, interactive controls, reactions, web target, actor system, package manager, and LSP/DAP editor tooling are all built; native/cdylib packages and multi-version registry resolution remain planned. The full grammar is in SPEC.md.

Architecture

arb's computational core runs on fusevm: the expression layer (src/expr.rs) lowers arithmetic to a fusevm::Chunk and executes on the shared VM (three-tier Cranelift JIT). Declarative widget/layout construction needs no VM and stays plain Rust — correct by design. The Tcl-flavored reader (src/lexer.rs, src/parser.rs, src/ast.rs) builds a Spec (src/spec.rs) that src/tui.rs renders and src/serve.rs serves over HTTP/WebSocket, with source bodies evaluated by the query pipeline (src/query.rs) over the live stream (src/stream.rs). Deps: fusevm, ratatui, clap, regex, serde_json/serde_yaml/scraper (formats), base64/percent-encoding (encode verbs), rayon (parallel fuzzy match), reedline (REPL).

src/lexer.rs     Tcl-flavored reader            (present)
src/parser.rs    widget cmds + expr grammar     (present)
src/ast.rs       syntax tree                    (present)
src/spec.rs      command tree -> Spec interp    (present)
src/expr.rs      expression -> fusevm::Chunk     (present)
src/query.rs     source query pipeline          (present)
src/actor.rs     actor system + via fan-out     (present)
src/theme.rs     31 color palettes + custom     (present)
src/rust_ffi.rs  inline rust { } FFI blocks     (present)
src/stream.rs    live stream state              (present)
src/tui.rs       ratatui backend + themes       (present)
src/serve.rs     HTTP + WebSocket web target    (present)
src/repl.rs      reedline REPL                  (present)
src/web.rs       static HTML export             (present)
src/lsp.rs src/dap.rs   stdio JSON-RPC          (present)

Transfers from siblings are mechanics only — fusevm embedding, the rkyv cache, the LSP/DAP stdio shape, the package-manager ABI. The language design (lexer / parser / AST / compiler / semantics) is arb-original.

Why arb

Building from source

arb builds as a standalone Rust crate:

# clone
git clone https://github.com/MenkeTechnologies/arb
cd arb

# build (debug)
cargo build

# run the M0 tail
find / | ./target/debug/arb

# install
cargo install --path .

License

arb is MIT licensed — free and open source. See LICENSE.

Repository & links

• Language reference — reference.html (every widget, query verb, directive, action, and input mode)
• Engineering report — report.html (architecture, world-first positioning, milestones)
• Language spec — SPEC.md (full grammar, widgets, query, controls, actors, packages)
• Source — github.com/MenkeTechnologies/arb
• Issues — github.com/MenkeTechnologies/arb/issues
• The shared VM — fusevm (also behind zshrs, stryke, rubyrs, elisp)