Beautiful and
interactive plots,
right inside
your terminal

compatibility

Your framework, your terminal — supported.

A first-class widget for your TUI framework, real pixels in your terminal. If your pair is below, plotui just works — and feels the same everywhere: drag rotates, shift-drag pans, scroll zooms, clicks pick.

TUI frameworks

Same engine behind all three — a plot looks and feels identical whichever framework hosts it.

Terminals

placeholder

the richest mode — plots are woven into the character grid, so they scroll, split, and repaint exactly like text

direct

pixels drawn straight at the plot's position, just as sharp — plotui manages repaints itself

~ partial

these terminals' pixel-graphics support is new and still maturing — plots work, with occasional rough edges

plotui detects your terminal and picks the best render path on its own — no configuration, and it works inside tmux too (plots pass straight through to the hosting terminal). Terminals without pixel graphics get a clear notice instead: plotui never degrades to a fake plot.

python · rust · go

from plotui import Plot

plot = Plot()

# the scene next to the header — one trace per cluster
plot.add_scatter3d(x_a, y_a, z_a, color=(230, 60, 120))
plot.add_scatter3d(x_b, y_b, z_b, color=(69, 200, 209))
plot.add_scatter3d(x_c, y_c, z_c, color=(240, 161, 60))

# forward your framework's events…
plot.rotate(d_yaw, d_pitch)
plot.zoom_by(factor)

# …and place the bytes
escape = plot.render_kitty(cols, rows, cell_w, cell_h)

use plotui_core::Plot;

let mut plot = Plot::new();

// the scene next to the header — one trace per cluster
plot.add_scatter3d(cluster_a, [230, 60, 120], 2.0);
plot.add_scatter3d(cluster_b, [69, 200, 209], 2.0);
plot.add_scatter3d(cluster_c, [240, 161, 60], 2.0);

// forward your framework's events…
plot.rotate(d_yaw, d_pitch);
plot.zoom_by(factor);

// …and place the bytes
let fb = plot.render(cols * cell_w, rows * cell_h);
let escape = plotui_protocol::kitty(&fb, cols, rows);

import plotui "github.com/sebaheg/plotui/go"

plot := plotui.New()

// the scene next to the header — one trace per cluster
col := plotui.WithColor
plot.AddScatter3D(xA, yA, zA, col(plotui.RGB{230, 60, 120}))
plot.AddScatter3D(xB, yB, zB, col(plotui.RGB{69, 200, 209}))
plot.AddScatter3D(xC, yC, zC, col(plotui.RGB{240, 161, 60}))

// forward your framework's events…
plot.Rotate(dYaw, dPitch)
plot.ZoomBy(factor)

// …and place the bytes
escape, _ := plot.RenderKitty(cols, rows, cellW, cellH, opts)

more live plots

Surfaces, and every 2D chart, from the same engine.

Like the header, these are in-browser re-creations of what the Rust rasterizer draws in your terminal: a Gouraud-shaded grid surface on the viridis ramp, and the 2D chart types with their automatic axes, ticks, and legend.

streaming

# handles come back from add_*
h = plot.add_line([], [], name="forecast")
o = plot.add_scatter([], [], name="observed")
g = plot.add_line([], [], name="load", axis="y2")

def feed():  # 20 times a second
    widget.extend(h, [t], [forecast(t)])
    widget.extend(o, [t], [measured(t)])
    widget.extend(g, [t], [load(t)])

widget.set_visible(o, False)  # legend toggle

get started

# clone, then:
❯ python -m venv .venv && source .venv/bin/activate
❯ pip install maturin textual
❯ maturin develop --release

# in Kitty / Ghostty / iTerm2 / WezTerm:
❯ python examples/raw_demo.py
❯ python examples/textual_graph.py

how it works

The Rust core owns pixels — not the terminal.

One rule shapes everything: the engine has no event loop and no input handling. Your TUI framework owns the loop, forwards input to the camera, and asks for a frame. Because the core and the protocol layer are pure and I/O-free, the same engine can back every frontend — and be unit-tested by hashing pixel buffers.

f64 data─▶camera + rasterizer─▶RGBA buffer─▶kitty escape bytes─▶your terminal's cell grid