Features Architecture Compare Roadmap
Docs Discord GitHub
Pre-Prototype · In Development

Build beautiful terminal UIs
the way you build web apps

A reactive TUI framework for Rust — Flexbox layout, declarative components, signal-based state management. Write rsx! macros, get stunning terminal interfaces.

See the Code Read Docs View on GitHub
termoxide_app 
#[component]
fn Counter(initial: i32) -> impl Component {
    let (count, set_count) = create_signal(initial);

    rsx! {
        <Box style={style!(
            flex_direction: column,
            padding: 1,
        )}>
            <Text>"Count: " {count}</Text>
            <Button on_click=move |_| set_count.update(|n| *n + 1)>
                "Increment"
            </Button>
        </Box>
    }
}█

Write This → Get This

Declarative rsx! macros let you describe your UI like React — but compiled, type-safe, and running natively in the terminal.

📝 Your Code 
#[component]
pub fn dashboard() -> impl Component {
  let tasks = create_signals(vec![
    "Setup CI/CD",
    "Write tests",
    "Deploy v0.1",
  ]);

  rsx!(
    <Box style={styles.container}>
      <Text style={style!("bold cyan")}>
        "📋 Task Manager"
      </Text>
      <List items={tasks} selectable={true}>
        {|task| rsx!(<Checkbox label={task} />)}
      </List>
      <Button style={styles.button.primary} onHover={style: styles.button.hover}>
        "+ Add Task"
      </Button>
    </Box>
  )
}

let styles = StyleSheet::create([
  container: {
    flex: 1,
    direction: "column",
    border: "rounded",
  };
  button: [
    primary: {
      bg: "blue",
      fg: "black",
    };
    hover: {
      bg: "light_blue",
    };
  ];
]);
🖥️ Terminal Output
📋 Task Manager
☑ Setup CI/CD
☐ Write tests
☐ Deploy v0.1
[ + Add Task ]

Why TermOxide?

Everything you need to ship production-grade terminal UIs — without the low-level pain.

Reactive Signals

React-like state management powered by reactive_graph. Signals, memos, and effects — your UI updates automatically when state changes.

Flexbox Layout

CSS-like positioning powered by the taffy layout engine. No more manual coordinate calculations — use direction, padding, gap, and flex.

Component Library

Ready-to-use Text, Button, TextInput, List, and Checkbox components. Fully stylisable, composable, and accessible out of the box.

Keyboard-First

Built-in FocusManager handles Tab/Shift+Tab navigation, focus traps for modals, and predictable tab order — zero config required.

RSX Macros

Write terminal UIs with a JSX-like declarative syntax directly in Rust. Type-safe, interpolation-ready, and familiar to web developers.

Accessibility

WCAG AA contrast ratios, keyboard navigation for all interactive elements, and respect for terminal high-contrast configurations.

Layered Architecture

Five strictly unidirectional layers. Each depends only on the one below — testable, modular, clean.

L5

Component Library

Text, Box, Button, TextInput, List, Checkbox

L4

Component System

ComponentTrait, rsx! macro, Props, Context, FocusManager

L3

Rendering Bridge

RenderLoop, Renderer, EventRouter, ViewNode → ratatui

L2

Layout Engine

LayoutEngine, CoordMapper, StyleSheet → taffy (Flexbox)

L1

Reactive Core

ArcRwSignal, ArcMemo, Effect, Resource → reactive_graph

Your application sits above Layer 5, consuming only the public API.

TermOxide vs Raw ratatui

ratatui is a fantastic rendering library. TermOxide builds on top of it to give you the full framework experience.

Aspect ratatui TermOxide
State Management Manual — you track everything yourself Reactive signals with automatic UI updates
Layout System Manual Rect splitting and coordinate math Flexbox via taffy — direction, padding, gap
Component Reuse DIY — no built-in component model ComponentTrait + Props + Context system
Event Handling Raw crossterm events, manual routing Automatic routing by focus & spatial position
UI Syntax Imperative — step-by-step operations Declarative rsx! macros (JSX-like)
Learning Curve Steep — low-level terminal knowledge required Familiar — React/Vue patterns in Rust

Built on solid foundations — TermOxide uses ratatui as its underlying rendering engine, complementing its immediate-mode capabilities with a robust state management layer, flexbox layout, and an intuitive component system.

Roadmap

TermOxide is in active pre-prototype development. Here's where we're headed.

Phase 1

Reactive Core + Layout

Signal system, Flexbox engine, basic rendering

In Progress
Phase 2

Component System

ComponentTrait, rsx! macro, Props, event routing

Phase 3

Widget Library

Text, Box, Button, Input, List, Checkbox

Phase 4

v0.1 Release

Docs, examples, crates.io, community launch

Want to follow the progress or contribute?

Star on GitHub Join Discord