API Reference Raxol v#2.6.0
View SourceModules
TEA module source templates for mix raxol.new.
Boilerplate content generators for mix raxol.new.
File creation orchestration for mix raxol.new.
Template descriptions and previews for mix raxol.new.
Mock terminal for testing plugins
Mock plugin runner for testing
Multi-surface application runtime for Elixir, built on OTP.
Records pilot interactions as time-series events.
Tracks pilot accept/reject decisions on layout recommendations.
Rule-based layout recommendation engine.
Pure functional layout interpolation between two layouts.
Axon MLP for layout recommendation inference and training.
Supervisor for the adaptive UI subsystem.
Pure functional trend detection across aggregate windows.
Handles accessibility concerns for the Animation Framework, specifically adapting animations for reduced motion preferences.
Handles animation adaptation based on user preferences and accessibility settings.
Animation framework stub for test compatibility.
Handles the processing of active animations and their application to state.
Time source for the animation system.
Declarative animation DSL for composing complex animation sequences.
Defines an animation with name, type, parameters, conditions and metadata.
Manages complex multi-stage animations with stages, options and context.
Sequence and animation compilation for the Animation DSL.
Represents an animation sequence with type, animations, options, conditions and context.
Transform calculation functions for the Animation DSL.
Provides standard easing functions for animations.
Coordinates the lifecycle of animations within Raxol.
Refactored gesture-driven interactions with GenServer-based state management.
GenServer implementation for Animation Gestures state management.
View DSL helpers for attaching animation hints to elements.
Declarative animation hint metadata attached to view elements.
Provides interpolation functions for different data types.
Manages the lifecycle of animations including starting, stopping, and completion handling.
Manages animation target paths and state structure utilities.
Force field implementation for physics simulations.
Physics engine for Raxol animations.
3D vector implementation for physics simulations.
Refactored StateManager that delegates to GenServer implementation.
GenServer implementation for animation state management in Raxol.
Main application module for Raxol terminal emulator.
Authentication and session management for Raxol.
HTML dashboard generation for Raxol benchmarks.
Test data generators for Raxol benchmarks.
Legacy analyzer module for backward compatibility. Delegates to the new modular benchmark analysis system.
Fixture TEA applications for benchmarking render throughput, input latency, and memory usage. Each app has known complexity and pure implementations (no subscriptions, no side effects).
Mixed 3-panel dashboard with text, table rows, and progress indicators.
Minimal TEA app: empty model, empty view.
Nested row > column > box > text, depth 3.
10 lines of text in a column.
100-row, 5-column table.
Benchmark suite for comparing Raxol against competitor terminal emulators.
Configuration and utilities for Raxol performance benchmarking. Centralizes benchmark settings, performance targets, and reporting configuration.
Domain-specific language for defining benchmarks in an idiomatic Elixir way.
Enhanced custom formatter for Benchee that provides better insights, performance analysis, and visual reporting for Raxol benchmarks.
Formats benchmark results as console tables, JSON, or Markdown.
Advanced memory pattern analysis for Raxol benchmarks.
Enhanced DSL for memory benchmarking with advanced assertions.
Advanced memory benchmarking dashboard and reporting system.
Detects performance regressions by comparing current results with baselines. Uses statistical methods to determine significant performance changes.
Generates comprehensive performance reports from benchmark results.
Comprehensive benchmarking suite for Raxol performance testing.
Test plugin for benchmark runner testing.
Generates realistic test scenarios and data for benchmarking. Includes real-world terminal sequences, user interactions, edge cases, and visualization data for comprehensive benchmark testing.
Advanced statistical analysis for benchmark results. Provides percentiles, distributions, outlier detection, and statistical significance testing.
Common statistical functions for benchmark analysis.
Handles storage and retrieval of benchmark results for historical analysis.
Central registry for all benchmark suites. Manages suite discovery, registration, and execution.
Static competitor reference numbers for context.
Benchmarks the event -> update -> view -> layout -> cells pipeline.
Benchmarks the view -> layout -> cells render pipeline at 5 complexity levels.
Benchmarks Lifecycle startup time from start_link to initialized state.
Benchmarks per-widget and composite memory usage.
Centralized color palette for consistent CLI styling.
CLI command for managing Raxol updates.
Enhanced error display for CLI output with intelligent suggestions.
Formats ErrorExperience suggestions for CLI output.
Animated progress spinners for CLI operations.
Cloud integration system for Raxol applications.
Command parser with tab completion, history, and argument parsing.
Pure functional in-memory virtual file system.
Compliance reporting utilities for Raxol.
Thin wrapper around Raxol.UI.Components.Base.Component.
Unified TOML-based configuration management for Raxol.
Generates configuration files and templates.
Configuration loading utilities for various formats and sources.
Configuration schema definitions and validation.
Schema definitions for all Raxol configuration sections.
Documentation generation for Raxol configuration schemas.
Validation logic for Raxol configuration values.
Centralized defaults for the Raxol framework.
Raxol Core - The main entry point and coordination layer for the Raxol framework.
Manages the integration between accessibility settings and the active theme.
Box drawing utilities for Raxol.Core.Buffer.
Compatibility layer for legacy Raxol.Core.Buffer references.
Circuit breaker implementation for external API calls.
Behaviour for clipboard operations.
Core color system for Raxol.
Thread-safe ETS table management for Raxol's plugin command registry.
Generic connection pooling implementation for external services.
Enhanced error experience system for Raxol applications.
Error Pattern Learning System - Error Experience
Load, save, import, and export functions for ErrorPatternLearner. All I/O is isolated here; the GenServer delegates persistence work to this module.
Prediction and suggestion enhancement for ErrorPatternLearner. All functions are pure and operate on the learner state map.
Manages context preservation across process restarts.
Manages dependency relationships between components for intelligent recovery.
Enhanced supervisor with intelligent error recovery strategies.
Wrapper module that adds recovery capabilities to any GenServer process.
Automatic error report generation system for Error Experience.
Enhanced error message templates for Error Experience.
Provides functions for generating unique identifiers.
Core metrics module for Raxol framework.
Metric aggregation system for the Raxol metrics.
Alert management system for the Raxol metrics.
Cloud integration for the Raxol metrics system.
Configuration management for the Raxol metrics system.
ETS-backed metrics collection for high-throughput metric recording.
Visualization system for the Raxol metrics.
Performance monitoring facade for Raxol.Core.
Platform detection utilities for cross-platform compatibility.
Provides clipboard read/write commands and delegates to a configured system clipboard implementation.
Defines the behaviour for clipboard plugin operations.
Core plugin responsible for handling notifications (:notify). Relies on an implementation of Raxol.System.Interaction for OS interactions.
Rendering utilities for Raxol.Core.Buffer.
Manages terminal buffer rendering with double buffering and damage tracking.
Provides comprehensive color support for terminal rendering.
Defines the core element structure for the rendering system.
Central layout coordinator for the Raxol renderer system.
Manages the rendering system for Raxol applications.
Provides view-related functionality for rendering UI components.
Border-related functions for the View module. Extracted from the main View module to improve maintainability.
Component creation functions for the View module. Extracted from the main View module to improve maintainability.
Handles box layout functionality for the Raxol view system. Provides box model layout with content, padding, border, and margin.
Handles scrollable views for the Raxol view system. Provides viewport management, scrollbar rendering, and content scrolling.
Handles text rendering for the Raxol view system. Provides text styling, wrapping, and alignment functionality.
Handles flex layout functionality for the Raxol view system. Provides row and column layouts with various alignment and justification options.
Handles grid-based layouts for the Raxol view system. Provides functionality for creating and managing grid layouts with customizable columns and rows.
Layout helper functions for the View module. Extracted from the main View module to improve maintainability.
Handles border rendering for the Raxol view system. Provides various border styles and rendering functionality.
Type definitions for the Raxol view system.
Provides utility functions for common view operations in the Raxol view system.
Validation functions for the View module. Extracted from the main View module to improve maintainability.
Chart view component for data visualization.
Table view component for displaying tabular data.
Defines the behaviour for Raxol applications following The Elm Architecture (TEA).
Refactored component manager with functional error handling patterns.
Debug logging functionality for the Raxol runtime.
Implements capture and bubbling event dispatch through the view tree.
Handles conversion between different event formats in the Raxol system.
Manages the application state (model) and dispatches events to the application's
update/2 function. It also handles commands returned by update/2.
Pure-function hooks extracted from Dispatcher for mouse hit testing, time-travel debugging, cycle profiling, and session recording.
Manages event handlers registration and execution in the Raxol system.
Handles keyboard event processing in the Raxol system.
Manages the application lifecycle, including startup, shutdown, and terminal interaction.
Component startup sequence for the Raxol application lifecycle. Extracted from Lifecycle to reduce file size.
Shutdown, cleanup, and registry management helpers for Lifecycle. Extracted from Lifecycle to reduce file size.
Public API for Raxol plugins to interact with the core system.
A GenServer wrapping a single component module for crash isolation.
Rendering backend implementations for different output targets.
Provides the core rendering functionality for Raxol applications with functional error handling.
Behavior for rendering engines.
Manages the rendering schedule based on frame rate.
Provides a way to subscribe to recurring updates and external events.
Supervises the core runtime processes of a Raxol application.
Centralized registry and supervisor for all Raxol GenServers.
Consolidated state management module providing functional, process-based, and ETS-backed state handling.
ETS-backed state operations for StateManager. All functions operate on a named ETS table.
Process-based state management strategy for StateManager. Each managed state ID corresponds to a named GenServer process.
Style utilities for Raxol.Core.Buffer.
Supervisor for all refactored GenServer-based modules.
Defines a behaviour for interacting with the operating system, allowing for mocking.
Handles OSC 4 (Color Palette Set/Query) commands.
Represents the core state of a terminal instance.
Handles text processing and formatting for UI elements.
Unified theme registry - single source of truth for all Raxol themes.
Refactored UX refinement module that uses GenUxServer for state management.
GenServer for managing UX refinement state.
Cryptographic utilities for Raxol.
Debug mode utilities and detailed logging for Raxol terminal emulator.
Interactive debugger UI for time-travel debugging -- "React DevTools for the terminal."
Pure functions for formatting Snapshot changes into styled display lines.
Pure functions for rendering a map/struct as an expandable tree.
A single point-in-time capture of a TEA update cycle.
Time-travel debugger for TEA applications.
Animated demos for the terminal showcase. Supports both SSH (direct IO) and web (message-based) output.
Command registry for demo terminal. Only whitelisted commands are executed. Validates input and blocks anything not explicitly registered.
Simple counter demo for mix raxol.demo counter.
Live BEAM dashboard demo for mix raxol.demo dashboard.
Generates demo content for the terminal showcase. Produces ANSI-formatted output demonstrating Raxol's capabilities.
Reusable visual effect helpers for demo animations.
Conway's Game of Life implementation for the demo showcase. Features age-based coloring where newer cells are brighter.
Self-driving 80x24 hero scene for the axol.io landing page (and X/GIF export).
Particle system for animated demo effects. Supports sparkles, explosions, trails, and floating elements.
GenServer managing demo terminal sessions. Enforces session limits and handles automatic cleanup.
Interactive component showcase for mix raxol.demo showcase.
ASCII text particle formation for demo effects. Uses 5x7 bitmap font to create particle target positions.
Task list demo for mix raxol.demo todo.
Watches lib/ for file changes and triggers recompilation + re-render.
A dynamic supervisor for starting Raxol application processes.
Animated border beam effect for terminal interfaces.
LiveView CSS generation for the BorderBeam effect.
Dispatches BorderBeam animation hints to the effect implementation
selected by opts[:type] and applies the result to a flat cell list.
Color palettes and gradient logic for the BorderBeam effect.
Contract + shared helpers for border-effect implementations.
A soft, non-directional shimmer along the entire perimeter.
Bright sparks flash at random perimeter positions. Each spark is a
jagged character (+ * # \ / x) painted in a vivid palette
color and bold. Position + char are deterministic from the time bucket,
so a given now_ms always produces the same crackle pattern.
Flickering flames climb the bottom edge of the box, with weaker echoes
on the left and right edges near the bottom. Per-cell character +
color choices come from bucket_hash/3 over a ~100ms time bucket, so
the effect looks chaotic but stays reproducible per tick.
The whole border breathes in unison: every perimeter cell shares the same fg color and intensity at any moment, both varying as a smooth cosine wave over the period.
A long bright comet sweeps clockwise around the border. The head is always the brightest palette color (bold); the trail fades through the palette and dims via terminal attrs.
Visual cursor trail for terminal interfaces.
Visual hover feedback for terminal widgets.
Dev-only Phoenix endpoint for Tidewave MCP integration.
Demo showcasing accessibility features including screen reader support, high contrast mode, and keyboard navigation.
A simple form component for demonstrating button integration. This is a stub implementation for test compatibility.
EXPERIMENTAL -- HEEx template integration for Raxol.
Terminal-specific Phoenix function components for HEEx templates.
Manages headless Raxol application sessions for non-interactive use.
Builds Raxol.Core.Events.Event structs from simple inputs.
MCP tool definitions for Raxol headless sessions.
Converts a Raxol.Terminal.ScreenBuffer into a plain text string.
Phoenix LiveView integration for Raxol.
Memory data collection for the memory debug tool.
Text, JSON, and Markdown output formatting for memory debug reports.
Memory leak detection and trend analysis.
Memory optimization analysis and recommendations.
Minimal Raxol terminal interface for ultra-fast startup.
VIM-style navigation for terminal buffers.
Adaptive performance optimizer that responds to real-world usage patterns.
Advanced alerting system for Raxol performance monitoring.
Analyzes performance metrics and generates insights for AI analysis.
Automated performance monitoring system for Raxol.
Cache behavior and utilities for Raxol performance optimization.
Shared cache get-or-compute pattern and telemetry for performance caches.
High-performance cache for component rendering results.
High-performance cache for font metrics calculations.
Profiles TEA update/view/render cycle timings.
Pure functions for computing statistics from cycle profiler timing data.
Performance hints system for development mode.
Development-mode profiler for detailed performance analysis.
Shared helpers for ETS-backed LRU and simple caches.
Shared utilities for ETS table lifecycle management.
High-performance ETS cache manager for Raxol hot paths.
Flame graph generation for performance profiling.
Thin wrapper around :fprof that isolates apply/3 calls.
Detects UI jank by analyzing frame timing.
GenServer implementation for function memoization cache.
Enhanced performance metrics collection system for Raxol.
Refactored Performance optimization strategies with GenServer-based memoization.
Performance profiling and optimization tools for Raxol.
Terminal playground for Raxol widgets.
Single source of truth for Raxol's widget catalog.
Shared helpers for playground demo TEA apps.
Playground demo: block-character bar chart with orientation toggle.
Playground demo: interactive button with click handling.
Playground demo: toggle checkboxes with keyboard navigation.
Playground demo: code display with line numbers and language samples.
Playground demo: scrollable container with viewport controls.
Playground demo: animated cursor trail with presets.
Playground demo: animated easing function showcase.
Playground demo: accessibility focus ring indicators.
Playground demo: 2D heatmap with color scale cycling.
Playground demo: streaming braille-resolution line chart.
Playground demo: markdown rendering with raw toggle.
Playground demo: selectable menu with keyboard navigation.
Playground demo: modal dialog with confirm and cancel actions.
Playground demo: panel focus highlighting with border styles.
Playground demo: password input with visibility toggle and strength meter.
Playground demo: progress bar with value tracking.
Playground demo: grouped radio buttons with h/l switching.
Playground demo: interactive Elixir REPL with sandboxed evaluation.
Playground demo: braille scatter plot with animated clusters.
Playground demo: dropdown select list with keyboard navigation.
Playground demo: compact sparkline with live data.
Playground demo: resizable split pane with direction toggle.
Playground demo: status bar with live-updating fields.
Playground demo: data table with sortable columns and row selection.
Playground demo: tab bar with keyboard switching and content panels.
Playground demo: multi-line text editor with insert and normal modes.
Playground demo: text rendering with style variations.
Playground demo: single-line text input with character counting.
Playground demo: expandable tree view with keyboard navigation.
Playground demo: in-memory virtual file system with shell-like commands.
Test helpers for Raxol plugins.
Handles the processing of rendered cells, allowing plugins to modify or replace them. Especially targets placeholder cells generated by the rendering pipeline.
Plugin for clipboard operations in Raxol.
Handles events for plugin system.
Common utilities and helper functions for event handling across plugins.
Handles input-related events for plugins.
Handles mouse-related events for plugins.
Handles output-related events for plugins.
Command Palette Plugin for Raxol Terminal
File Browser Plugin for Raxol Terminal
File system entry structure for the file browser.
Git Integration Plugin for Raxol Terminal
Example plugin demonstrating the Plugin System v2.0 capabilities.
Internal state for the rainbow theme plugin.
Example tests for the Rainbow Theme Plugin. Demonstrates how to test plugins with the new system.
Status Line Plugin for Raxol Terminal
Command routing for the TerminalMultiplexerPlugin.
Pane operations for the TerminalMultiplexerPlugin.
Layout rendering for the TerminalMultiplexerPlugin.
Window operations for the TerminalMultiplexerPlugin.
Terminal Multiplexer Plugin for Raxol Terminal
Terminal pane within a multiplexer window.
Multiplexer session containing multiple windows.
Window containing multiple panes.
Plugin that detects URLs in terminal output and makes them clickable.
Plugin that enables displaying images in the terminal using the iTerm2 image protocol. Supports various image formats and provides options for image display.
Handles the lifecycle management of Raxol plugins.
Handles dependency validation, circular dependency checks, and load order resolution for plugin lifecycle management.
Handles error formatting, logging, and result handling for plugin lifecycle management.
Handles plugin initialization, config merging, struct creation, and compatibility checks for plugin lifecycle management.
Handles manager state updates, config persistence, and plugin state management for plugin lifecycle management.
Handles field and config validation helpers for plugin lifecycle management.
Behaviour for plugin lifecycle management.
Plugin manager for Raxol. Handles plugin lifecycle, registration, and state management.
Handles cell processing functionality. Provides functions for processing and transforming cells through plugins.
Handles plugin event processing. Provides functions for processing various types of events through plugins.
Handles plugin hook execution. Provides functions for running various plugin hooks and collecting their results.
Handles plugin state management and updates. Provides functions for updating plugin state and managing plugin lifecycle states.
Defines the behavior for Raxol terminal emulator plugins. Plugins can extend the terminal's functionality by implementing this behavior.
Handles persistence of plugin configurations. Stores and loads plugin configurations from disk.
Provides utilities for plugin dependency and API compatibility checks.
Plugin for text search functionality.
Assertion helpers for plugin testing
Benchmarking utilities for plugin performance testing
Custom assertions for plugin testing
Test helper functions for common plugin testing scenarios. Note: This module provides additional helpers specific to the PluginTestFramework. For basic test helpers, see Raxol.Plugins.Testing.Helpers.
Helper functions for plugin testing
Mock terminal implementation for plugin testing
Plugin runner for test environments
Plugin Testing Framework for Raxol
Plugin that manages terminal themes and color schemes. Allows users to apply predefined themes or create custom color schemes.
Handles rendering logic for chart visualizations within the VisualizationPlugin.
Utility functions for drawing basic shapes and text onto a cell grid. Used by visualization renderers.
Handles rendering logic for image visualization within the VisualizationPlugin. Supports both sixel and kitty protocols for terminal image rendering.
Handles rendering logic for treemap visualizations within the VisualizationPlugin. Uses a squarified layout algorithm.
Plugin responsible for rendering visualization components like charts and treemaps. It receives data structures from the view rendering pipeline and outputs actual terminal cells.
Policy definition framework for Raxol.
Exception raised when authorization fails.
Privacy and GDPR compliance utilities for Raxol.
Compatibility layer for performance profiling.
Defines protocols for the Raxol framework.
Adapter module to help migrate from behaviours to protocols.
Wrapper for buffer modules to enable protocol dispatch.
Wrapper for event handler modules to enable protocol dispatch.
Wrapper for renderer modules to enable protocol dispatch.
Protocol implementations for buffer operations on existing buffer types.
Protocol for buffer operations in terminal emulation.
Protocol-based component framework for Raxol.
Represents an instance of a protocol-aware component.
Domain-specific language for defining protocol-aware components.
Protocol for handling events in a polymorphic way.
Integration layer between the existing event system and the new EventHandler protocol.
Event bus for protocol-aware event handling.
Enhanced event structure with protocol support.
Integration layer for the plugin system with protocol support.
Registry for managing plugins and their capabilities.
Protocol-aware plugin structure.
Protocol module for handling protocol-related functionality.
Protocol for rendering data structures to terminal output.
Protocol implementations for terminal renderer types.
Protocol for serializing and deserializing data structures.
Protocol for applying styles to data structures.
Protocol implementations for theme-related structures.
Protocol implementations for UI components.
PubSub system for Raxol.
Safe query building utilities for Raxol.
Role-Based Access Control for Raxol.
Elixir code evaluator with timeout protection, IO capture, and persistent bindings.
AST-based safety checker for REPL code evaluation.
Shell-like helper functions for the virtual filesystem in REPL sessions.
Rate limiting utilities for Raxol.
Serializes and deserializes asciinema v2 .cast files.
Replays recorded terminal sessions from .cast files.
GenServer that captures terminal output and input during a live Raxol session.
Data structure for a recorded terminal session.
Video render target: turn a Raxol screen buffer into a rasterized frame.
Encodes a directory of PNG frames into a video file via FFmpeg.
Behaviour for turning a standalone HTML document into a single PNG frame.
Rasterizer backend backed by ChromicPDF's warm headless-Chrome session pool.
Rasterizer backend that shells out to an installed headless Chrome/Chromium.
Repository module for Raxol. Currently a stub as Raxol doesn't use Ecto database operations.
SSH app serving for Raxol TEA applications.
I/O adapter for SSH sessions.
Serves a Raxol TEA application over SSH.
Manages a single SSH connection's TEA application lifecycle.
Sandbox execution environment for untrusted code.
Search system with fuzzy, exact, and regex matching.
Refactored Security User Context module with GenServer-based state management.
GenServer implementation for Security User Context management.
Defines style properties for terminal UI elements.
Defines border properties for terminal UI elements.
Provides utilities for color accessibility, focusing on WCAG contrast.
Generates and validates accessible color palettes based on WCAG contrast requirements.
Suggests accessible color alternatives based on WCAG contrast requirements.
Detects terminal capabilities and adapts color schemes accordingly.
Provides advanced color handling capabilities for the terminal.
Core color representation and manipulation module.
Color format conversion utilities.
Creates and manages color gradients for terminal applications.
Provides functions for HSL color space conversions and adjustments.
Provides functions for generating color harmonies based on a base color.
Provides hot-reloading capabilities for color themes.
Manages color palette generation and scale creation with accessibility considerations.
Handles persistence of color themes and user preferences.
Refactored Color System module with GenServer-based state management.
GenServer implementation for the color system in Raxol.
Shared color utilities for the Raxol color system.
Handles layout styling for Raxol components.
Behaviour for convergent replicated data types (CRDTs).
Last-Writer-Wins Register CRDT.
Observed-Remove Set CRDT.
Bandwidth-aware synchronization manager.
Automatic node discovery via libcluster.
Health and latency tracking for cluster nodes.
Composites multi-node state into cell tuples for rendering.
libcluster strategy that discovers BEAM nodes via Tailscale.
Supervisor for the distributed swarm subsystem.
CRDT-backed shared state visible to all nodes.
Manages node roles and handles promotion/demotion on failure.
Provides consolidated access to the system clipboard across different operating systems.
Handles delta updates for the Raxol terminal emulator.
Behaviour for a system adapter used by DeltaUpdater.
System adapter implementation for delta updater.
A behaviour for abstracting system environment interactions.
Concrete implementation of EnvironmentAdapterBehaviour using Elixir's System module.
Behaviour for abstracting system interactions like running commands, finding executables, and getting OS type. Allows for easier testing.
Concrete implementation of the System.Interaction behaviour using standard Elixir/Erlang functions.
Platform-specific functionality and detection for Raxol.
Utility for running external commands with stdin input via Port.
Terminal-specific platform features and compatibility checks.
Provides version management and self-update functionality for Raxol.
Core update logic and GenServer callbacks for the Raxol System Updater.
Network operations for the Raxol System Updater including HTTP requests, GitHub API, file downloads, and archive operations.
Refactored System Updater State module with GenServer-based state management.
GenServer implementation for the System Updater state management.
Validation functions for the Raxol System Updater including version checking, platform detection, and settings validation.
Theme management system for Raxol terminal.
Internal multi-framework adapter layer.
Handles border rendering logic and border character definitions.
Handles cell operations, clipping, merging, and coordinate management.
Block-character bar chart with sub-character precision.
A dot-addressable canvas that renders to Unicode braille characters.
Shared utilities for chart rendering: scaling, range computation, axis/legend cell generation, and data normalization.
2D heatmap with background-color intensity mapping.
Braille-resolution line chart with multicolor multi-series support.
Braille-resolution scatter plot for 2D {x, y} data.
Converts chart cell tuples to View DSL elements for use in TEA view/1.
Test utilities for Raxol UI components.
Absolute / overlay layer primitive for terminal chrome.
Provides base functionality and utilities for Raxol components.
Defines the behavior for UI components in the Raxol system.
Provides component lifecycle hooks and management for UI components.
Renders a block of code with syntax highlighting.
Calculates layout bounds for widgets within a grid configuration. This module provides functions to determine the position and size of widgets based on a grid layout definition (columns, rows, gaps).
Handles saving and loading dashboard widget layouts to disk.
A progress bar component for displaying completion status.
A non-interactive status bar that displays key-value pairs separated by a configurable delimiter.
Styled text rendering with wrapping, alignment, and truncation.
A tree view component with expand/collapse and keyboard navigation.
A scrollable container that displays a windowed view of content that may exceed its visible bounds.
Focus ring component for accessibility and keyboard navigation.
Hint display component for contextual help and tooltips.
Button component for user input.
Checkbox component for toggling boolean values.
A nested menu component with keyboard navigation.
A multi-line input component for text editing, supporting line wrapping, scrolling, selection, and accessibility.
Clipboard operations for MultiLineInput component.
Event handler for MultiLineInput component. Handles keyboard input and navigation events.
Message routing for MultiLineInput component. Handles routing different message types to appropriate handler functions.
Navigation helper functions for MultiLineInput component cursor movement and selection operations.
Rendering helper functions for MultiLineInput component.
Text manipulation helper functions for MultiLineInput component.
Password field input component for secure user input. This is a thin wrapper around Raxol.UI.Components.Input.TextField, setting secret: true by default. All features, options, and behaviour are inherited from TextField.
A component that allows users to select an option from a list.
Navigation helper for SelectList component. Handles arrow key navigation, home/end, and page up/down.
Pagination helper for SelectList component. Handles page-based navigation and state management.
Rendering logic for SelectList component.
Search/filter functionality for SelectList component.
Selection management for SelectList component.
Shared utility functions for SelectList component modules. Eliminates code duplication between Navigation and Selection modules.
A simple single-line text input component.
A tab bar component with keyboard navigation.
Text area input component for multi-line user input. This is a thin wrapper around Raxol.UI.Components.Input.MultiLineInput for API compatibility. All features, options, and behaviour are inherited from MultiLineInput.
Shared text editing operations for input components.
A text field component for single-line text input.
A text input component for the Raxol UI system.
Utility functions for text wrapping.
Cached version of text wrapping utilities with performance optimizations.
Renders Markdown text into styled Raxol elements for terminal display.
A modal component for displaying overlay dialogs like alerts, prompts, confirmations, and forms.
Core state management and initialization for the Modal component.
Event handling and keyboard navigation for the Modal component.
Rendering logic and form field rendering for the Modal component.
State management and form validation for the Modal component.
Provides components for displaying progress, like progress bars and spinners.
Progress bar component for terminal UIs.
Circular progress indicator component.
Indeterminate progress indicator component.
Animated spinner component for terminal UIs.
Table component for displaying and interacting with tabular data.
A terminal emulator component that wraps EmulatorLite to display a fully functional terminal within the UI.
Terminal emulator component wrapping the core emulator logic.
Handles rendering of specific UI element types (box, text, table, panel).
Tracks keyboard events and provides accessibility support.
Tracks scroll events for virtual scrolling components.
Helpers for widgets to determine focus state from the render context.
Integration testing utilities for Raxol applications.
Universal drag and drop system for all Raxol UI components.
CSS Grid layout system for Raxol UI components.
Grid cell definition specifying position and span.
Grid item with placement information.
Handles grid item placement: explicit placement via grid-area / grid-row / grid-column, occupancy-grid construction, and auto-placement (grid-auto-flow).
Calculates final pixel positions for placed grid items given sized tracks.
Track sizing for CSS Grid: resolves auto, fr, min-content, max-content, and minmax() tracks based on item content and available space.
Grid track (row or column) definition.
Parses CSS Grid track definitions (grid-template-columns / grid-template-rows).
Handles layout calculations for container elements like rows and columns.
Handles measurement of basic UI elements like text, labels, boxes, and checkboxes.
Core layout engine that translates the logical view structure into absolute positions.
Modern Flexbox layout system for Raxol UI components.
Container sizing and the legacy calculate_layout/distribute_flex API.
Flex grow/shrink space distribution along the main axis.
Main-axis and cross-axis positioning for flex items, including justify-content and align-items logic.
Line-breaking logic for flex-wrap containers, and multi-line layout orchestration.
Grid layout utility functions.
Handles measurement of input elements like buttons and text inputs.
Shared utilities for layout calculations.
Default ScrollContent adapter that wraps a plain list.
Handles layout calculations for panel UI elements.
An element with pre-computed text measurements.
Walks an element tree and produces PreparedElements with cached text measurements.
Responsive layout system with breakpoint support for terminal UI components.
Behaviour for content sources that support cursor-based streaming.
Layout processor for split pane elements.
Helpers for interactive split pane resize in TEA applications.
ScrollContent adapter for lazy/streaming data sources.
Shared style inheritance logic for layout containers.
Table layout operations for the UI system.
Performance testing utilities for Raxol UI components.
UI Renderer for Raxol terminal applications.
Cached version of the UI Renderer that leverages component caching.
High-performance cache for component rendering results.
Handles composition of UI rendering trees.
Tracks damaged/dirty regions in the UI tree to optimize rendering. Only re-renders areas that have actually changed, reducing unnecessary work.
Handles layout of UI components.
Cached version of the Layouter that uses ETSCacheManager for performance.
Handles painting of UI components to the terminal.
Batches multiple render requests within animation frames to optimize performance. Coalesces rapid UI updates into single render operations.
GenServer responsible for managing rendering state and applying animation settings. Receives commands from the rendering pipeline and coordinates rendering actions.
Centralized timer management for the UI rendering pipeline.
Provides functions to compute the difference (diff) between two UI trees. This module is responsible for identifying changes, additions, removals, and reordering of nodes, supporting both keyed and non-keyed children.
React-style Context API for Raxol UI components.
Definition structure for a context.
Context provider that supplies values to descendant components.
Unified GenServer for UI state management, handling both store operations and component hooks without Process dictionary usage.
Refactored UI State Store with GenServer-based state management.
Action structure for state changes.
Internal state structure for the Store.
Subscription to state changes in the Store.
Shared style/theme merging for UI components.
Handles style processing, merging, inheritance, and flattening.
A terminal UI rendering module for Raxol.
Single source of truth for text display width measurement.
Consolidated theme resolution, color processing, and theme-related utilities.
Cached theme resolution module providing backward compatibility.
Color management utilities for theme handling.
Registry for custom color palettes used in the Raxol theming system.
A component for selecting and applying themes.
Theme management for Raxol UI components.
Defines the behaviour for Theme services.
Unified manager for themes and color palettes in the UI system. Consolidates ThemeManager and ColorManager functionality.
Universal features available across all UI frameworks in Raxol.
Visual regression testing utilities for Raxol applications.
Utility functions for color conversions between hex and RGB formats.
Shared formatting utilities for human-readable output.
Common utility functions for map operations.
Utility functions for formatting memory values.
Main view module for Raxol.
Basic view components for Raxol UI rendering.
Backward-compatibility shim for view elements.
Top-level interrupt/resume API for Raxol.Workflow.*.
Asynchronous execution surface for Raxol.Workflow.Compiled graphs.
Typed reducer declaration for a state-map key.
An append-only snapshot of a workflow run's state at a specific step.
Behaviour for Raxol.Workflow.Checkpoint persistence.
DETS-backed Raxol.Workflow.Checkpoint.Saver adapter.
ETS-backed Raxol.Workflow.Checkpoint.Saver adapter.
Postgrex-backed Raxol.Workflow.Checkpoint.Saver adapter.
Frozen, validated workflow ready for execution.
Edge descriptors for Raxol.Workflow.Graph.
Edge whose chooser.(state) returns the next node id, or a list
of node ids for parallel fan-out.
Static edge from from to to.
Edge that is taken only when guard.(state) returns truthy.
Barrier descriptor for a join node.
Per-task execution state for workflow runs that use interrupt / resume.
Immutable graph builder for Raxol.Workflow.
Node descriptors for Raxol.Workflow.Graph.
A node backed by a module implementing Raxol.Workflow.Node.
Protocol for executing Raxol.Workflow.Node.TypedNode structs.
A node backed by a 1-arity function.
A node backed by a struct implementing
Raxol.Workflow.Node.Executor. Used by external packages to
register semantically-named nodes with custom telemetry.
Execution runtime for Raxol.Workflow.Compiled graphs.
Merges the terminal states of fan-out branches at a join.
Mix Tasks
Main entry point for Raxol development tasks.
Enhanced benchmarking task for Raxol terminal emulator.
Advanced benchmarking commands leveraging the new world-class infrastructure.
Enhanced memory benchmarking task for Raxol terminal emulator.
Advanced memory analysis task.
Run comprehensive quality checks on the Raxol codebase.
Validate documentation counts against actual code.
Converts GenServer modules to use BaseManager behavior.
Interactive debugger for time-travel debugging Raxol TEA applications.
Runs built-in Raxol demo applications.
Generate flame graphs for performance analysis.
Generates a new Raxol TEA component module and test.
Automatically generates type specs for private functions in Raxol modules.
Unified memory analysis and profiling tools.
Memory debugging tools for detecting leaks, hotspots, and optimization opportunities.
Memory performance gates for CI/CD integration.
Interactive memory profiler for real-time memory analysis.
Long-running memory stability tests for detecting memory leaks and performance degradation.
Custom mutation testing for Raxol using simplified approach.
Generates a new Raxol application.
Performance analysis and optimization tools for development.
Automated performance monitoring task for Raxol.
Interactive terminal playground for browsing Raxol widgets.
Records a Raxol application session to an asciicast (.cast) file.
Render a TEA module (or .exs file path) to a video file or a single image.
Interactive Elixir REPL powered by Raxol's terminal UI.
Replays a recorded Raxol session from an asciicast (.cast) file.
Enhanced test runner for the Raxol project.