Skip to main content

Build Beautiful Terminal UIs with Native Performance

Kraken TUI combines Rust’s native performance with TypeScript’s ergonomic API to create interactive terminal interfaces that are fast, composable, and production-ready.

Native Performance

Rust core powers layout, rendering, and text parsing — zero overhead

TypeScript DX

Familiar API with both imperative and JSX/signal-driven patterns

Flexbox Layout

Taffy-powered flexbox engine with familiar CSS-like properties

Rich Text

Built-in Markdown rendering and syntax highlighting

Quick Example

import { Kraken, Box, Text, KeyCode } from "kraken-tui";

const app = Kraken.init();
const root = new Box({ 
  width: "100%", 
  height: "100%", 
  flexDirection: "column" 
});

const label = new Text({ 
  content: "Hello, Kraken!", 
  fg: "#00FF00", 
  bold: true 
});

root.append(label);
app.setRoot(root);

let running = true;
while (running) {
  app.readInput(16);
  for (const event of app.drainEvents()) {
    if (event.type === "key" && event.keyCode === KeyCode.Escape) {
      running = false;
    }
  }
  app.render();
}

app.shutdown();

Key Features

Comprehensive Widget Library

Box, Text, Input, TextArea, Select, ScrollBox — all the building blocks you need

Animation System

Smooth property transitions with easing, chaining, and choreography support

Theming

Built-in dark/light themes with per-widget-type style defaults

Event Handling

Keyboard, mouse, focus, resize — full event system with hit-testing

Architecture

Kraken TUI follows a modular monolith with cross-language facade pattern:
  • Rust Native Core — Owns all state, layout computation, rendering, and text parsing
  • TypeScript Host Bindings — Thin ergonomic wrapper over FFI with zero business logic
  • FFI Boundary — Clean command protocol with opaque handles and safety guarantees
Core Invariant: Rust is the performance engine; TypeScript is the steering wheel. All CPU-intensive work executes in the native core.

Get Started

Installation

Install Kraken TUI and build the native core

Quickstart

Build your first terminal UI in minutes

Core Concepts

Understand the architecture and design principles

API Reference

Explore the complete API documentation

Why Kraken TUI?

You get Rust’s performance without writing Rust. The FFI boundary lets TypeScript developers leverage native execution speed for layout, rendering, and text parsing — all the CPU-intensive work happens in compiled code.
Flexbox layout via Taffy means you can use the same mental model as web development. No learning archaic terminal coordinate systems or manual positioning — just flexDirection, justifyContent, and alignItems.
Start with the imperative API for maximum control, or use JSX with signals for reactive UIs. The reconciler handles efficient updates so you can write declarative code without sacrificing performance.
Built with production in mind: comprehensive error handling, animation budgets, dirty-flag diffing, and extensive testing. v2 is complete with safe state management, accessibility support, and full widget lifecycle.

When to Use Kraken TUI

Interactive Dashboards

System monitoring, CI/CD status, real-time metrics visualization

CLI Tools

Config wizards, interactive installers, development tools

AI Agent Interfaces

Terminal-based agent interfaces with rich interaction models

Developer Tools

Log viewers, debuggers, REPLs, and other developer utilities

Project Status

Kraken TUI is pre-GA and not production-ready yet. v1 is complete (themes + animation foundation). v2 is complete (state hardening, tree operations, JSX reconciler, accessibility). v3 planning is underway.

Community & Support

GitHub Repository

View source code, report issues, and contribute

License

Apache License 2.0 — open source and permissive

Build docs developers (and LLMs) love