tt-toplike — Real-Time Tenstorrent Hardware Monitoring

See it live

Hardware monitoring as performance art

Four Blackhole chips, idle and under inference load, rendered simultaneously. Watch the Tensix cores brighten as power climbs, DRAM channels report training state, and the NoC particle stream shifts with real traffic.

Watch on YouTube →

You put four Blackhole chips in a rack.
You fire up an LLM inference job.
And then — nothing. A blinking cursor. A log file.

We wanted to see it. Watch the DRAM channels train one by one at boot. Watch Tensix cores light up when the attention heads fire. See the NoC traffic as a river of particles moving between chiplets. Watch the temperature blush orange as the workload grows.

Not numbers in a table. Not a dashboard with gauges. A living picture of inference in motion.

What you see

Every pixel earns its place

There are no decorative animations. Every visual element is driven by real telemetry from the hardware — if it's moving, something changed on the chip.

✦

Tensix Core Grid

Each star in the starfield is a real Tensix core. Its brightness tracks power consumption relative to the learned idle baseline. Its color shifts from cool cyan through yellow to hot red as temperature rises. The twinkle rate follows current draw. 224 cores on Blackhole, every one individually represented.

▓

DRAM Channel Status

The DDR training bitmask from SMBUS telemetry is parsed per-channel and rendered in real time: ○ untrained, ◐ training (animated), ● trained, ✗ error. On Blackhole that's 12 channels — you can watch them come up one by one during the boot sequence.

◆

Memory Hierarchy

The Memory Dungeon renders all four levels simultaneously: DDR at the base, L2 cache banks in the middle, L1 SRAM cores above, Tensix compute at the top. Four distinct particle types — Read ○◉, Write □■, CacheHit ◇◆, Miss ●⬤ — flow upward as real transactions complete.

∿

NoC Particle Flow

The Memory Flow visualization maps the Network-on-Chip as a 2D field. Particles stream between the DDR perimeter and the Tensix core array, their density proportional to traffic, their color to temperature. Watch the flow change as inference shifts attention layers.

◈

Inter-Chip Topology

Hardware topology is auto-detected from board_type. Dual-chip carrier boards (p300, n300, QB2) show board groupings with ═══ / ←→ inter-chip links. Independent PCIe cards (p150a, n150) display as equal-weight columns with no spurious board labels — the board concept is suppressed entirely. Scales from 2 to 32+ chips: side-by-side columns up to terminal width, then a compact fleet grid with one power bar per chip.

@

Arcade Hero

Arcade mode places a roguelike hero character at the intersection of power (vertical) and current (horizontal). Its color is temperature. It leaves a trail of recent positions. It's your avatar inside the chip — moving through DDR, L2, L1, and Tensix as the workload climbs.

Visualization modes

Seven ways to watch your hardware think

Press v to cycle, or jump directly with a (Arcade), d (Defrag), g (Insights). Every mode reads the same live telemetry — power, temperature, aiclk, DDR state — and renders it differently. Recordings below are from real 4× Blackhole hardware.

g · default

Insights

Live per-chip telemetry panels. Power, temperature, DDR training status, ARC firmware health, and an active process list — all in one view. The adaptive baseline learns your chip's idle state so all activity is shown relative to what's normal for your hardware.

↑↓ navigate processes k silence alerts K kill process l legend ! explain

v · starfield

Tensix Starfield

Every Tensix core is a star. Brightness encodes power fraction above idle; color hue encodes die temperature (cyan at cool, red at hot); character weight (·∘○◉●) encodes activity level; twinkle phase encodes current draw. During LLM inference, stars pulse in sync with each token's compute burst then settle back to idle shimmer.

l legend ! explain signals

v · castle

Memory Castle

A roguelike dungeon representing the memory hierarchy: DDR at the bottom, L2 cache in the corridors, L1 and Tensix at the top. 600 particles per chip flow upward — Read, Write, CacheHit, and CacheMiss each rendered differently with trails. Spawning density and speed track live power. During inference the dungeon fills and seethes; at idle it breathes slowly.

l legend ! explain signals

v · flow

Memory Flow

GDDR channels as horizontal streams. One bar per DDR channel (up to 12 on Blackhole); fill state shows trained/active status; particles flow left-to-right with speed and density driven by bandwidth. Hue rotates 30° per channel so all 12 fan across the full color wheel. Most meditative mode — watch the inference rhythm emerge as a wave.

l legend ! explain signals

d · defrag

Defrag

Norton SpeedDisk-style block map: one row per GDDR channel, blocks fill left→right as model weights DMA in. During inference, blocks glow — brightness from power, saturation from GDDR temperature, palette shifting warmer as the chip heats. Scatter bursts flash on power spikes (each token's compute burst visible as a flash). When a model unloads, the EVICT animation dissolves blocks right→left at prime-staggered rates, then DMA rebuild restarts from scratch.

d jump here directly l legend ! explain signals

a · arcade

Arcade

All visualizations at once: Starfield (top 40%), Memory Castle + Defrag block map side-by-side (middle 30%), Memory Flow (bottom 30%). A @ hero character roams the canvas — X position = current draw, Y position = power, color = temperature, speed and trail length = aiclk and ETH link count. The fullest picture of what your hardware is doing.

a jump here directly l legend ! explain signals

--host

Host CPU mode

No Tenstorrent hardware? Run tt-toplike --host on any Linux machine. CPU frequency maps to aiclk, package temperature to die temp, RAM usage to DDR fill. Every visualization works — your CPU cores glow as stars, your RAM drives the DDR channel bars. A useful way to explore all modes before TT hardware arrives.

--host flag --host --mode arcade

Screenshots

Real hardware, real data

Captured on Blackhole hardware during live LLM inference. No mock data.

Insights mode — 4× Blackhole at 58–77W, live LLM inference

tt-toplike arcade mode — four Blackhole chips at 58–66W under live inference load, showing Tensix starfield, memory castle particle hierarchy, and NoC flow

Arcade mode — 4× Blackhole at 58–66W, live LLM inference

tt-toplike fleet grid — 64 simulated devices in compact multi-chip layout

Fleet grid — 64-device compact layout

Lineage & inspiration

Standing on the shoulders of
beautiful tools

Every design decision in tt-toplike traces back to something that came before it — a game, a tool, a film, an art installation. Here's the direct lineage.

It started with a question: why does every hardware monitoring tool look like a 1995 spreadsheet? The hardware underneath is doing something genuinely spectacular — billions of SRAM operations per second, twelve DDR channels training in parallel, a mesh network-on-chip routing inference tokens across 224 Tensix cores — and the best we offer the operator is a table of numbers that refreshes every five seconds.

The Python ancestor of this tool (tt-top) proved the concept: a terminal can be a window into the chip. tt-toplike reimplements that vision in Rust, pushing the frame rate to 100ms, adding the adaptive baseline system that makes every machine look alive regardless of its power envelope, and extending the visualization language to cover things tt-top never attempted — DRAM training state, inter-chip topology, the full memory hierarchy rendered as a living dungeon.

The design vocabulary draws from a very specific set of predecessors. Not dashboards. Not Grafana panels. Games, art tools, and the terminal programs that dared to be beautiful.

1982

Missile Command & Yar's Revenge

Atari 2600 titles that proved a handful of pixels could carry enormous urgency. The particle systems in Memory Castle and Memory Flow inherit their kinetic grammar — objects with velocity, brief lives, and color that means something — directly from these two games.
1982

TRON (film)

The visual metaphor of a human navigating the interior of a computer is the animating concept behind Arcade Mode. The grid aesthetic, the glowing wireframes, the sense that the machine has interior geography worth exploring — all TRON. The TRON Grid visualization mode is a direct homage.
1993

NetHack / Dungeon Crawl Stone Soup

Roguelikes proved that ASCII art could have depth, atmosphere, and meaning. The Memory Castle visualization treats each character on screen as a semantic glyph — ○◉ are reads, □■ are writes, ◇◆ are cache hits. The dungeon aesthetic (layers, particles, environmental glyphs) comes directly from this tradition.
2004

htop

The invention of the modern terminal monitor. Colored bars, real-time updates, a layout that made the CPU visible. tt-toplike inherits htop's fundamental premise — the terminal is a legitimate UI, not a fallback — and extends it from CPU threads to an entire AI accelerator chip.
2009

Logstalgia

A web-server log visualizer that renders HTTP requests as a Pong-style particle game. The insight: any time-series data can be a particle system. Every DRAM transaction, every cache miss, every NoC packet is an event with a source, a destination, and a brief existence — exactly what Logstalgia taught us to see.
2020

btop++

The modern heir to htop — richer colors, smoother animations, more information per pixel. The vibrant color palette in tt-toplike (deep blue-gray backgrounds, bright teal accents, psychedelic HSV cycling) is a direct response to btop++'s proof that terminal tools can look genuinely beautiful.

Technical foundation

Built on safe defaults and live telemetry

tt-toplike is a Rust library with multiple frontends — a TUI binary, a PTY-hosted native window, and a hybrid backend that streams telemetry from tt-smi without ever touching PCI BAR0 while a workload is running.

🛡

Non-Invasive by Default

The default backend chain is Sysfs → JSON (tt-smi subprocess) → Mock. Direct PCI access via Luwen is only attempted when --backend luwen is passed explicitly. You can monitor an LLM inference job without any risk of disturbing the hardware state.

⚡

Streaming SMBUS at 1.5s

The HybridBackend spawns a persistent tt-smi subprocess that loops every 1.5 seconds, writing RS-delimited JSON records to a pipe. A reader thread parses each record and deposits it via an Arc-swap pointer — zero mutex contention on the render path, no 5-second polling surge.

〜

EMA Smoothing

Numeric SMBUS fields (temperature, power, clock frequencies) are blended through an exponential moving average (α=0.25) as each new snapshot arrives. Hard value jumps are distributed across ~4 frames, eliminating the visual discontinuity that makes monitoring tools feel choppy.

🖥

tt-toplike-app

A native egui window that hosts the full TUI inside a PTY — no terminal emulator needed, no font configuration, no rendering artifacts. Launches tt-toplike-tui as a child process, implements a complete VT100/VT220 screen renderer including deferred auto-wrap, and draws each cell via egui with full color fidelity.

🔀

Live Backend Switching

Press b in the TUI to cycle backends without restarting. The visualization state is preserved; only the data source changes. Useful for comparing Sysfs sensor readings against full SMBUS telemetry side-by-side during the same session.

📦

Debian Package

Ships as two Debian packages: tt-toplike (the TUI, ~750 KB stripped) and tt-toplike-app (the native window, ~4 MB with egui). All crates are vendored for offline reproducible builds. Recommends tt-smi and tenstorrent-dkms from the Tenstorrent PPA.

Get started

Install

Grab the Debian package for the fastest path. Or build from source with Cargo.

1

Download the packages that match your Ubuntu version. Two variants ship per release: _noble.deb for Ubuntu 24.04+, _jammy.deb for Ubuntu 22.04+.

SUITE=$(. /etc/os-release && echo "$UBUNTU_CODENAME")
[ "$SUITE" = "noble" ] || SUITE="jammy"
gh release download --repo tenstorrent/tt-toplike --pattern "*_amd64_${SUITE}.deb"

2

Install both packages:

sudo dpkg -i tt-toplike_*_amd64_${SUITE}.deb tt-toplike-app_*_amd64_${SUITE}.deb

3

Run with mock hardware to verify — or on real Tenstorrent silicon:

tt-toplike --mock --mock-devices 4        # no hardware needed
tt-toplike                             # auto-detects real hardware
tt-toplike --mode arcade               # start in arcade mode
tt-toplike-app                         # native window (PTY-hosted TUI)

4

Or build from source (requires Rust 1.75+):

git clone https://github.com/tenstorrent/tt-toplike
cd tt-toplike
cargo build --release --bin tt-toplike-tui --features tui
./target/release/tt-toplike-tui --mock --mock-devices 4

Keyboard shortcuts: v cycle viz mode b switch backend q / ESC quit r force refresh

Watch inference happen.

Hardware monitoring as performance art

Every pixel earns its place

Seven ways to watch your hardware think

Real hardware, real data

Standing on the shoulders ofbeautiful tools

Built on safe defaults and live telemetry

Install

Watch
inference
happen.

Standing on the shoulders of
beautiful tools