One Elixir TEA module rendered to terminal, browser, SSH and MCP.
raxol.io ↗repo ↗docs ↗MCP as a rendering target (feature doc) ↗ADR-0012 MCP as rendering target ↗Time-travel debugging doc ↗Hex package ↗Author's vision post ↗
Closest philosophical twin with mature ideas (focus lens, derived tools, authorization, time-travel API) worth copying, but it is code-first Elixir and cannot replace a data-first, agent-authored Rust UI.
Borrow from it: take a specific idea, API or format.
Raxol is the only project found that took the same bet as thc-scene seriously and at depth: one Elm-architecture source of truth, many projections, and the agent as a first-class surface rather than a screen scraper. Its MCP layer is principled, not bolted on: tools are derived from the live component tree with functor-law property tests, filtered by an attention-aware focus lens so the model sees ~15 relevant actions, and guarded by a fail-closed authorization model that thc-scene has not designed yet. It already ships what thc-scene has only planned: update-by-update time travel with diff/restore/export, asciicast recording and replay, an MCP test harness, and the same app served to terminal, browser (LiveView) and SSH. It sits on the BEAM, so crash isolation, hot code reload while running and distribution come free. For an Elixir shop that wants agents to operate a terminal app with semantic actions instead of keystrokes, it is already further along than anything else.
| UI as data | 3 scene 5 | view output is an Elixir data tree (and the structured screenshot is JSON-friendly), but the UI is authored as Elixir code, not a pushable wire value |
|---|---|---|
| Agent can drive it | 4 scene 5 | first-class operation of a live instance over MCP; creation/change of UI requires writing code, so not 5 |
| Agent can see it | 5 scene 5 | text screen plus structured widget tree plus model and resources |
| Small, targeted edits | 3 scene 5 | id-addressed semantic actions on components, but no patching of the UI definition itself |
| Time travel | 4 scene 0 | rich history API (diff, jump, restore, export) usable from code; not exposed as MCP tools per docs |
| Live data rate | 3 scene 5 | 5 ms full frame claimed; no streaming/patch-rate numbers |
| Terminal native | 5 scene 5 | |
| Pixel graphics | 2 scene 4 | kitty/sixel code present (emulator parser, image plugin); renderer-side pixel output not verified |
| Teaching | 2 scene 3 | |
| Maturity | 2 scene 1 | v2.7 on Hex but ~80 stars and two known users |
| Openness | 4 scene 4 | MIT, but single-author controlled |
Raxol scene now scene planned
MCP server (`mix mcp.server`, stdio; SSE transport too) with tools derived automatically from the running component tree, plus headless session tools (raxol_start/screenshot/send_key/get_model/stop/list) and MCP resources for model projections. Also ACP server for its own coding agent.
Low for an Elixir app: write the TEA module, run mix mcp.server, add it to Claude Code. High if you are not on the BEAM: the UI must be written in Elixir.
Yes, structured: raxol_screenshot returns plain text plus a JSON-friendly widget summary (type, id, role, label, value, focused, children); raxol_get_model returns the model; resources stream state diffs; a ContextTree combines model, component tree, focus chain, agents and notifications.
The agent addresses components by id and calls semantic actions on the live instance (type_into, click, select_row). It cannot push or patch the UI structure itself as data; changing the UI means changing Elixir code (hot-reloadable).
Raxol.Debug.TimeTravel records every update; step_back/step_forward/jump_to/diff/restore/export/import are an Elixir API, not documented as MCP tools. Agent-session journal supports --replay and /rewind for the coding agent. Terminal recording to .cast.
The most agent-aware TUI framework found: every component is an MCP tool and the screen is readable as structure. But the agent operates a UI a developer wrote; it does not author or patch the UI as data at runtime.
An app is one TEA module (init/update/view) running as an OTP GenServer. view returns an Elixir element tree that is projected to four surfaces: terminal (termbox2 NIF), browser (Phoenix LiveView), SSH (Erlang :ssh) and agents (MCP). Each interactive component implements a ToolProvider behaviour, so the MCP server derives namespaced tools (e.g. component.search_input.type_into) from the live tree on every render and announces changes with tools/list_changed. Model state is published as MCP resources through app-declared projections and streamed as diffs. BEAM gives per-component crash isolation, hot code reload and distribution (CRDT swarm state).
Published microbenchmarks from an in-repo bench suite (measured 2026-08-07 at a stated commit). No numbers for agent-driven update rates, patches/s or streaming data throughput.
Very small adoption: 80 stars and a few thousand Hex downloads. The two named users are the author's own product and one hobby BBS.
Used by: Xochi (author's own DEX trading surface), foglet-bbs (SSH bulletin board by Brendan Turner)
Extremely active and heavily documented (ADRs, golden render-determinism suite, dialyzer gate), but effectively a one-person project with a very wide scope (UI runtime, coding agent, payments, chat gateways, orchestration).
Releases: Roughly monthly Hex releases: 2.6.0 2026-07-11, 2.6.1 2026-08-07, 2.7.0 2026-09-10; raxol-cli tags v0.2.6 2026-08-09 to v0.2.10 2026-09-10 · Contributors: 14 entries in the GitHub contributors API including anonymous and dependabot; DROOdotFOO has 2,241 commits, next are ndreynolds 153 and merklebonsai 153 · Recent: 723 commits on master since 2026-07-11 (90 days); last push 2026-10-09 · Bus factor: low: one author wrote the large majority of commits
Elm architecture, a live process an agent drives, structured readback of screen and state, id-addressed components, recording/replay and time travel, hot code reload keeping state.
Agent-addressable history (raxol already records message + model before/after per update with diff/jump/restore/export); a fail-closed authorization model for agent tool calls; a pipe-friendly agent test harness; multi-surface rendering. Raxol's MCP surface is more mature than scene's current socket (which has no MCP server yet).
Raxol's UI is Elixir code; an agent cannot push a whole UI or patch a node definition as JSON at runtime, bind data sources to shell commands/JSON streams that bypass the model, or draw a kitty pixel layer with callouts/spotlights. thc-scene is language-neutral data-first; raxol is code-first.
| 1–7 | home · features · use cases · docs · changelog · under the hood · blog |
| t | light or dark |
| j k | scroll |
| g G | top · bottom |
| ? Esc | this · close |