Recursively, axol. Forever FOSS.

Write one app. Render it to a terminal, a browser, an SSH session, or an agent.

Your application is a single TEA module (init, update, view) running as an OTP GenServer. Raxol renders that module to four surfaces from one codebase:

                          +---> Terminal (termbox2 NIF)
                          |
  TEA module (GenServer) -+---> Browser (Phoenix LiveView)
                          |
                          +---> SSH (Erlang :ssh)
                          |
                          +---> Agent (MCP tools)

The interesting part is the runtime. Your app gets crash isolation per Component, hot code reload without restart, distributed clustering with CRDTs, and an agent surface where LLMs interact with structured Component trees instead of scraping pixels. Those are BEAM properties, from a VM built for systems that can't go down, can't lose state, and hot-swap code while running.

Bubble Tea, Ratatui, and Textual are excellent renderers. A2UI and AG-UI define agent-UI wire formats. Raxol is the runtime that renders all four surfaces from one source module. See Why OTP for the full comparison.

Xochi is a private cross-chain DEX: intent-based swaps across 6 chains, sub-3s settlement, stealth addresses by default, ZKSAR compliance proofs. Its entire trading surface is raxol. A trader terminal serves over SSH with a dark-pool aesthetic, the same TEA module renders as a LiveView web UI, a solver-agent surface lets Riddler's sub-2ms solver consume auto-derived MCP tools to bid on intents, and an ops cockpit runs sensor fusion on solver health. The solver agent and the human trader read the same Component tree through different projections.

foglet-bbs by Brendan Turner is an SSH-only retro bulletin board (bbs.foglet.io, ssh bbs.foglet.io) that stress-tested raxol's SSH path into shape.

Raxol is a runtime for agents as much as for humans. Every interactive Component automatically exposes MCP tools (Button gives click, TextInput gives type_into/clear/get_value), and a focus lens filters to roughly 15 relevant tools per interaction. Where A2UI and AG-UI define how agents talk to UIs at the wire level, raxol generates the UI and the agent surface from one Component tree: same source, two projections.

import Raxol.MCP.Test
import Raxol.MCP.Test.Assertions

session = start_session(MyApp)

session
|> type_into("search", "elixir")
|> click("submit")
|> assert_component("results", fn c -> c[:content] != nil end)
|> stop_session()

mix mcp.server starts the MCP server on stdio for Claude Code integration.

The agent subsystems ship as standalone packages:

• Pay (raxol_payments): wallets, ledger-enforced spending limits, and transparent auto-pay when an agent hits an HTTP 402, across five protocols (x402, MPP, Xochi cross-chain, Permit2, Riddler).
• Earn (raxol_acp): the sell side. Declare an offering, implement two callbacks, and a buyer agent discovers it, escrows funds, and settles on-chain through the Virtuals ACP job lifecycle (request, negotiation, transaction, evaluation, completed), one supervised process per job. Pre-alpha.
• Improve (raxol_agent): a solved task becomes a reusable SKILL.md. A background reviewer runs on a cheap model after each turn, writing durable memory and new skills without spending the live turn's latency or context.
• Reach (raxol_gateway): one adapter contract to many chat platforms, process-per-chat sessions, DM pairing for authorization, and /handoff to move a conversation across platforms with its history intact.
• Orchestrate (raxol_symphony): an OTP port of OpenAI Symphony that polls a tracker, isolates each issue in its own workspace, and runs a coding agent, feeding six surfaces (terminal, LiveView, MCP, Telegram, Watch, JSON API) from one snapshot.

# mix.exs
def deps do
  [{:raxol, "~> 2.4"}]
end

Or generate a new project:

mix raxol.new my_app

git clone https://github.com/DROOdotFOO/raxol.git
cd raxol && mix deps.get
mix raxol.playground          # 30 live demos, browse/search/filter

The flagship demo is a live BEAM dashboard with scheduler utilization, memory sparklines, and a process table:

mix run examples/demo.exs

See examples/README.md for the full learning path, including agent examples, swarm demos, and the sandboxed REPL.

Full frame in 2.1ms on Apple M1 Pro (Elixir 1.19 / OTP 27), 13% of the 60fps budget.

Unix/macOS backend uses a termbox2 NIF; Windows uses a pure Elixir driver (usable, not yet tuned). See the benchmark suite.

Start here

• Quickstart
• Core Concepts
• Component Gallery

Cookbook

• Building Apps
• SSH Deployment
• Theming
• LiveView
• Performance

Reference

• Architecture
• Buffer API
• Benchmarks
• API Docs

Advanced

• Agent Framework
• Agentic Commerce
• Sensor Fusion
• Distributed Swarm
• Recording & Replay
• Why OTP

Standalone packages: grab just the subsystem you need. See PACKAGES.md for the full table.

git clone https://github.com/DROOdotFOO/raxol.git
cd raxol
mix deps.get
MIX_ENV=test mix test --exclude slow --exclude integration --exclude docker
mix raxol.check              # format, compile, credo, dialyzer, security, test
mix raxol.check --quick      # skip dialyzer
mix raxol.demo               # run built-in demos

Raxol started as two converging ideas: a terminal for AGI, where AI agents interact with a real terminal emulator the same way humans do; and an interface for the cockpit of a Gundam Wing Suit, where fault isolation, real-time responsiveness, and sensor fusion are survival-critical. The Gundam thing sounds like a joke. Then you look at the constraint set and it's exactly what OTP was built for: systems that can't go down, can't lose state, and have to hot-swap components while running.

MIT. See LICENSE.md.