Quick Start Protocol

Get
Started.

Install the kernel, write your first model, and breathe life into your terminal in under five minutes.

Not ready to install? Try FrankenTUI in your browser first — no setup required.

Try the Live Demo

Requires Chrome or Edge (WebGPU)

Deployment

Installation

Add the monster to your Rust project with a single command.

Command Line
$cargo add ftui

Manual Stitching

Prefer fine-grained control? You can depend on individual crates to minimize your binary footprint.

ftui-coreftui-renderftui-runtime
Hello Monster

Minimal App

A complete, runnable counter in under 50 lines.

src/main.rs
01
use
ftui_core::event::Event;
02
use
ftui_core::geometry::Rect;
03
use
ftui_render::frame::Frame;
04
use
ftui_runtime::{App, Cmd, Model, ScreenMode};
05
use
ftui_widgets::paragraph::Paragraph;
06 07
struct
TickApp {
08 ticks: u64,09}10 11#[
derive
(Debug, Clone)]
12
enum
Msg {
13 Tick,14 Quit,15}16 17
impl
From<Event>
for
Msg {
18
fn
from(e: Event) -> Self {
19
match
e {
20 Event::Key(k)
if
k.is_char('q') => Msg::Quit,
21 _ => Msg::Tick,22 }23 }24}25 26
impl
Model
for
TickApp {
27
type
Message = Msg;
28 29
fn
update(&
mut
self
, msg: Msg) -> Cmd<Msg> {
30
match
msg {
31 Msg::Tick => {32
self
.ticks += 1;
33 Cmd::none()34 }35 Msg::Quit => Cmd::quit(),36 }37 }38 39
fn
view(&
self
, frame: &
mut
Frame) {
40
let
text = format!("Ticks: {} (press 'q' to quit)",
self
.ticks);
41
let
area = Rect::new(0, 0, frame.width(), 1);
42 Paragraph::new(text).render(area, frame);43 }44}45 46
fn
main() -> std::io::Result<()> {
47 App::new(TickApp { ticks: 0 })48 .screen_mode(ScreenMode::Inline { ui_height: 1 })49 .run()50}
Syntax_Validation_Active
UTF-8_ENCODED
Architecture

The Three Pillars

The foundational invariants that set FrankenTUI apart.

Elm Model

Pure state transitions. No hidden I/O. Logic stays clean and testable.

Inline First

Preserve terminal history while keeping UI chrome stable.

One-Writer

Zero race conditions. All output flows through a single serialized gate.

Intel

Common Queries

Clarifications on the monster protocol.

Why the name FrankenTUI?
Because it's stitched together from the best parts of modern software engineering (the Elm architecture, flexible layout solvers) but animated by a completely new heart: a deterministic, math-heavy rendering kernel that brings interfaces to life without the flicker or state-corruption of 'natural' TUI frameworks.
Is it really built in 5 days?
Yes. 100 hours of focused engineering. Every algorithm was selected for its correctness and performance under pressure. The result is an 'alien artifact' quality codebase that moves fast without breaking things.
Does it support my terminal?
If your terminal supports ANSI escape sequences, FrankenTUI will animate it. It detects capabilities at startup and downgrades gracefully: from true color to mono, from hyperlinks to plain text, and from synchronized output to safe-buffered writes.
How does it compare to Ratatui?
Ratatui is the established giant, but it's a 'view-only' library that leaves architecture to the user. FrankenTUI is a complete kernel. It provides the runtime, the event loop, and the invariants (like the One-Writer Rule) that prevent bugs before they are even stitched into your code.
What is the 'One-Writer Rule'?
It's the surgical discipline that ensures only one component ever writes to the terminal. By funneling all output through a single serialized gate, we eliminate cursor corruption and race conditions, ensuring the terminal display remains pristine even under heavy stress.
Does FrankenTUI work in the browser?
Yes. FrankenTUI compiles to WASM via wasm-pack and renders at 60fps in Chrome and Edge using WebGPU. The same Rust code, the same deterministic rendering pipeline, running directly in the browser with zero DOM overhead. Try the live demo at frankentui.com/web.

Keep exploring.