Building a TUI is easy now

Alex,

It's somewhat ironic that a web page about performant terminal user interfaces uses gratuitously complex CSS mask compositing and cubic gradients which reduce smooth scrolling on my 1 year-old, high-end Dell XPS laptop (>$3k) to Commodore 64 level (on default 'Balanced' battery mode). While it's pretty, it's also just a very subtle, non-critical background animation effect. Not being a CSS guru myself, here's what Gemini says:

> "Specifically, this is a Scrim or Easing Gradient. Instead of a simple transition between two colors, it uses 16 color stops to mimic a "cubic-bezier" mathematical curve. This creates a smoother, more natural fade than a standard linear gradient, but it forces the browser to calculate high-precision color math across the entire surface during every scroll repaint."

My Firefox smooth scrolls like butter on thousands of pages, so you might want ask your web designer to test on non-Mac, iGPU laptops with hiDPI and consider the performance cost of web pages with always-running subtle background animations in a world of diverse hardware platforms. In case it helps, here's the animation with the gradient layers disabled so you can see all 6,400,000 pixels which are being recalculated every scroll line (https://i.imgur.com/He3RkEu.jpeg).

   (
   printf 'GET /blog/tuis-are-easy-now HTTP/1.0\r\n'
   printf 'Host: hatchet.run\r\n\r\n'
   )|busybox ssl_client hatchet.run \
   |(echo "<meta charset=utf-8>";grep -o "<p.*</p>") > 1.htm
   firefox ./1.htm

I think TUIs-that-want-to-be-GUIs (as opposed to terminal commands just outputting plain text) are sad. Mainly because they’re largely inaccessible. They flatten the structure of a UI under a character stream. You’re forced to use it exactly the way it was designed and no different. Modern GUIs, even web pages too, expose enough structure to the OS to let you use it more freely. I get why people build TUIs, but it’s a sorry state of affairs.

Building a TUI was easy before, especially with the great toolsets for their respective languages BubbleTea / Textualize / Ratatui. And thanks to those frameworks, LLMs can manifest useful tools.

Similar to WebApps, it's only since the November'25 renaissance that I felt I could use them to create TUIs. Once I had that revelation, I started going into my backlog and using it.

I maintain a TUI Charting library, NTCharts. In January, I fixed a bug - totally obvious once identified - that I personally failed to find earlier. But the test harness, prompting, and Gemini got it done [1]. Gemini's spatial understanding was critical in completing the task.

I've been vibe-crafting a local LLM conversation viewing tool called thinkt. After scraping ~/.claude and making a data model, this is the point in PROMPTS.md where I start creating the TUI using BubbleTea. [2].

[1] https://github.com/NimbleMarkets/ntcharts/issues/7#issuecomm...

[2] https://github.com/wethinkt/go-thinkt/blob/main/PROMPTS.md#2...

As LLMs consume all our compute resources and drive up prices for the compute hardware on which we run applications, the silver lining is that LLMs are helpful in implementing tooling without a heavy stack so it will run quickly on a lower-spec computer.

I've achieved 3 and 4 orders of magnitude CPU performance boosts and 50% RAM reductions using C in places I wouldn't normally and by selecting/designing efficient data structures. TUIs are a good example of this trend. For internal engineering, to be able to present the information we need while bypassing the millions of SLoC in the webstack is more efficient in almost every regard.

I think mc (Midnight Commander) is still one of the best TUIs available - it's very close in capability to the GUI versions (like Double Commander) and it has the benefits of tuis - like that you can run it on a remote system. It looks outdated, but I'm actually now working on a new skin that will hopefully be included in the next release of mc.

I genuinely don't understand the TUI obsession for LLM applications.

Go watch copilot drive VS2026 if you've never seen it in action. There is no way you are going to be able to communicate this same amount of information via plain text in the same amount of time. I can catch a lot of bad stuff mid-flight because I can actually multitask my UI and click into diffs as files are edited in real time.

I don't see any real advantage of TUIs over web forms or GUIs for the same thing.

I do like CLIs though, especially the ones that are properly capable of working in pipelines. Composing a pipeline of simple command-line utilities to achieve exactly what you want is very powerful.

Gemini built a nice TUI for me for a DHT scraper project I was coding:

https://imgur.com/a/u3KHbDT

It was like two-shot, cos the first version had some issues with CJK chars.

I was impressed as it would have taken me a bunch of screwing around on lining up all the data etc when I wanted to concentrate on the scraping algorithm, not the pretty bits.

Some of my personal favourites TUI are all over GitHub and there are lots of them to have a look at can be found here:

https://github.com/rothgar/awesome-tuis

https://terminaltrove.com/explore/

Building for Charm, ratatui and many others is really getting much easier than before thanks to AI.

I love Claude Code, but how they made the TUI is just plain stupid. Not how it looks, but you know, the React part.

Indeed. Over a few days of iterations I had this TUI built for fast full-text search of Claude Code or Codex sessions using Ratatui (and Tantivy for the full-text search index). I would never have dreamed of this pre coding agents.

https://pchalasani.github.io/claude-code-tools/tools/aichat/...

The thing with TUIs is that, using mobile native virtual keyboards, it's apparently quite impossible to make them behave in a sane way in browsers!

I think the only reasonable option seems to be reimplementing one yourself, which is massively stupid.

"Building X is easy now"... it was never hard if you had the patience to read docs.

We should be saying "Building X is faster now" instead. But I guess that doesn't induce god complex that effectively.

Building TUIs was already super easy in 1990 with Turbo Vision and Clipper on MS-DOS, with compiled languages (TP, xBase), using super fast build times on systems running at 10 Mhz, within 640 KB.

Hi everyone, I enjoyed building this TUI for myself and wanted to write down how I did it. I appreciate all the thoughts and feedback! The web app is our main investment, but I think there's a slice of developers who really like to interact with TUIs, so I'm going to keep working on it.

For the demo at https://tui.hatchet.run, to answer some messages asking about it: I built this with the fantastic ghostty-web project (https://github.com/coder/ghostty-web). It's been a while since I've used WASM for anything and this made it really easy. I deployed the demo across six Fly.io regions (hooray stateless apps) to try to minimize the impact of keystroke latency, but I imagine it's still felt by quite a few people.

Turbo C++ was peak TUI. Even on hardware thousands of times slower than today it had that instantaneous wired-to-the-machine feeling that I rarely experience today.

I never turn down a chance to plug my favourite TUI - jjui, for controlling jj vcs. Life changing combination (and jjui is built with Charm)

https://github.com/idursun/jjui/

I too enjoy the charm TUI libraries, and have been using them to build a settlers of Catan game[0]. And some features are really cool, like different colors depending on dark/light theme.

They have a bunch of functions that concatenate strings, which may not be very efficient compared to using string.builders, but I haven't yet had performance problems.

However I haven't had such a great experience with AI, IMO they're bad at ASCII art.

[0]: https://sr.ht/~vicho/el_poblador/

> Notably this was the first time I felt that using Claude Code for something non-arbitrary was significantly faster than doing it myself

Well, it is like code completion on a higher level.

I still don't like this approach. Besides, who is going to maintain that code? Such code will probably forever be required to be maitnained via Claude. So no humans involved. Just autogenerated stuff. I dislike this idea a lot.

Humans are slower, ok, but they built excellent software before Claude. What is coming next? Claude Linux-like Kernel? Top500 supercomputers will run it?

Hey! This looks great, and I appreciate the effort! But just opening the page at https://tui.hatchet.run/ causes my (admittedly old Intel i7 9700K) to spin up its fans and consume >30% of the CPU without me even doing anything. I don't think a TUI should do that.

I was also intrigued by it being a lot of Go dependencies as I have developed a bit of a fancy for this language recently.

Big reason why TUIs were popular in the first place is because they are so much simpler to build. Compare ncurses to GTK/Qt, they are completely different leagues. One of my pet ideas is to build a ncurses compatible/style library that skips terminal layer and instead renders directly to Wayland, kinda getting the simplicity of ncurses without dragging all the legacy junk with it.

I knew this would be ANOTHER ai glazing post before even clicking. I think we must specify if a post is about AI in titles. Another "I built X" with AI really brings nothing to the table, and I've seen a few users agree with me on this.

https://news.ycombinator.com/item?id=46580844

Here's a similar situation, a submission called "webdev is fun again", and what you find inside is just gushing about how good AI is. Genuinely what value does it bring? I think this phenomenon is literally "clickbaiting" but on hackernews

Other users from here seem to see the same thing that I do:

https://news.ycombinator.com/item?id=47008412

https://news.ycombinator.com/item?id=47010624

Building an article is easy now.

TUIs are great fun and Claude can make beautiful ones with a little ratatui action super fast. However, the downside of these are that you can't use them with Claude Code so while I have a few I prefer to also have a prompt-response CLI function since that's better for lots of things.

What‘s the TUI equivalent for mobile apps? Big UI elements and text, iOS 1-6 style, rendered without bitmap graphics?

I.e. something that is lightweight, lightning fast, great to use with just a thumb or so and looks a bit boring and dated, yet also inviting?

Building TUIs might be easy now but building good user experience on a TUI is feels harder than ever has been to me. The modern libraries make a lot of things easy but we are currently pushing terminals far beyond what they were designed for.

Claude Code et.al. are good examples of that. Diffs, user approval flows, non-linear flows in general and a ton of text buffered are all elements that we know really well how to handle in web interfaces but are challenging for the terminal.

Dagger has a really nice TUI built on Charm. It reads OTEL to create an interactive tree for your builds and containers. If you have cloud setup, it will also push that all to a webapp interface where you can share and navigate in perpetuity. This works for both CI and local runs, super cool for sharing links to failed builds during dev, even while the dev's local build is still running

https://www.youtube.com/watch?v=EPEGTfaFnpA

The problem with TUI's, that we have all Stockholm syndrom'd ourselves, is that I can't use the mouse cursor to click to the position on the screen and edit the command line.

I haven’t done much with Claude code yet but I’ve watched some rather recent videos of other people leverage it to get work done and I couldn’t help thinking, are we going to end up with a similar UI but with fully deterministic “agents” at the end of this hype cycle.

All of the skills I saw demonstrated were deterministic. So does this end in a Functional Core, Imperative Shell scenario that looks like a Terraform Plan and a search engine-style natural language processor out front?

If it was so easy Anthropic wouldn't have messed up CC for so long. The author takes for granted the availability of good off-the-shelf TUI libraries for his chosen language.

Do we want tuis?

I can’t stand Gemmin-CLI. That tui gets in the way constantly

I’m mixed in jj’s tui. It’s better than no ui tho

Mostly tho I’m curious when I’d want a tui. Most of the time in a terminal I don’t want one

Looks great. Curious why not choose Rust and do extension of https://ratatui.rs/?

The cursor CLI was a great springboard for me to make my own frontend to prompt from, I would never use it though god, I implemented git, difs, and chat histories, so i can use it easily from my phone with tailscale. It picks up on my rules and can grep my project, so easy. https://imgur.com/a/HZOEvr7

Claude Code has done a good job of building a tui MUD client (I couldn’t find one I liked), and then building a GUI version using Tauri where all the config is shared, so you can run it as either a GUI (on any platform) or TUI. Happy with it so far, and I personally use both TUI mode or GUI mode (with floating panes) depending on what I’m doing.

I was working on a fairly niche thing, a library of crossplane compositions written in KCL and thought it would be nice to have a TUI so i could browse through them and see the rendered yaml as claude was working on it. I asked claude code to write it with python and textual and it one shotted it in about two minutes including a test suite.

With Claude, I built a TUI for managing QEMU/KVM VMs (Rust with ratatui.) Solves a lot of problems I had with virt-manager, so I made it a FOSSS project. https://www.vm-curator.org.

There are plenty of great tools available these days. Bubbletea would be my tool of choice, I think:

https://github.com/charmbracelet/bubbletea

They are! I (well, Claude) built nitpick as a TUI HN client, and it was surprisingly easy to do.

https://github.com/fragmede/nitpick

it's always been easy with ansi... Everyone just thinks it's hard because there's no React for TUI's until recently. '\x1b[' is all you need.

It was good enough for ncurses, it's good enough today.

Charm looks good. What is the TUI library of choice for python these days?