Raxol is a world-class terminal UI framework for Elixir.

It provides a comprehensive set of components and tools for building beautiful, accessible, and responsive terminal applications with enterprise-grade features and sub-millisecond performance.

Features

• Modern Component Library: A rich set of pre-built UI components like buttons, text inputs, tables, modals, and more.

• Accessibility Support: Built-in features for screen readers, high contrast mode, and keyboard navigation.

• Theming System: Customize the look and feel of your application with consistent theming.

• Responsive Layouts: Create layouts that adapt to different terminal sizes.

• The Elm Architecture: Follows TEA (The Elm Architecture) for predictable state management.

• Event Handling: Comprehensive event system for keyboard, mouse, and terminal events.

Getting Started

To create a new Raxol application, you need to define three core functions:

• init/1: Initializes your application state
• update/2: Updates the state based on events
• render/1: Renders the UI based on the current state

Here's a simple counter example:

```text
defmodule Counter do
  @behaviour Raxol.Core.Runtime.Application

  require Raxol.Core.Renderer.View
  alias Raxol.Core.Runtime.Events.Event

  def init(_opts) do
    {%{count: 0}, []}
  end

  def update(%{count: count} = model, %Event{type: :command, data: :increment}) do
    {%{model | count: count + 1}, []}
  end

  def update(%{count: count} = model, %Event{type: :command, data: :decrement}) do
    {%{model | count: count - 1}, []}
  end

  def update(model, _event_or_msg), do: {model, []}

  def view(model) do
    Raxol.Core.Renderer.View.column [padding: 1] do
      [
        Raxol.Core.Renderer.View.text("Count: #{model.count}"),
        Raxol.Core.Renderer.View.row [gap: 1] do
          [
            Raxol.Core.Renderer.View.button "-", on_click: {:command, :decrement},
            Raxol.Core.Renderer.View.button "+", on_click: {:command, :increment}
          ]
        end
      ]
    end
  end
end

# Start the application
Raxol.run(Counter)
```

Architecture

Raxol is built on the Elm Architecture (TEA) for predictable state management:

1. Model: Your application state
2. Update: Logic to update the state based on messages
3. View: Pure functions to render UI based on the current state

Messages can be generated by user interactions (like button clicks) or system events (like terminal resize).

Core Modules

• Raxol.Terminal - Terminal emulation and control
• Raxol.Component - Component-based UI development
• Raxol.UI - Layout engines and UI utilities
• Raxol.Events - Event handling and distribution
• Raxol.Plugin - Plugin system for extensibility
• Raxol.Audit - Enterprise audit logging
• Raxol.Security - Encryption and security features

Quick Examples

Simple Terminal

{:ok, terminal} = Raxol.start_terminal(width: 80, height: 24)
Raxol.execute(terminal, "ls -la")
Raxol.stop_terminal(terminal)

Component-Based UI

defmodule MyApp do
  use Raxol.Component

  def init(_), do: %{items: []}

  def render(state, _) do
    Raxol.UI.Layout.flexbox([
      {:box, %{}, "Header"},
      {:box, %{flex: 1}, render_items(state.items)},
      {:box, %{}, "Footer"}
    ], direction: :column)
  end
end

Minimal Mode (Ultra-fast)

# Sub-10ms startup, 8.8KB memory
{:ok, term} = Raxol.Minimal.start_terminal()
Raxol.Minimal.send_input(term, "echo 'instant'")

Performance

• Parser: 3.3μs/op (30x faster than standard)
• Memory: 2.8MB per session (44% below target)
• Startup: <10ms in minimal mode
• Rendering: 1.3μs for simple components

Each component follows consistent patterns for styling and behavior.