Comment by krismatja
8 hours ago
Interesting that Jane Street has taken an interest in TUIs, I think mostly this renaissance is partly due to the current bloat of Electron GUIs.
There are other great examples of TUIs that i've seen around the web:
https://github.com/ratatui/awesome-ratatui
https://terminaltrove.com/explore/
https://github.com/rothgar/awesome-tuis
But I think we will swing back to using GUIs when we find a performant way of making them, I don't know what it is yet but surely someone is working on this.
TUIs look good to look at though!
I've been making a modern Slack terminal client (https://github.com/gammons/slk) and it's been a joy to use daily. There are a few things that IMO have unlocked a fantastic TUI experience:
- TUI libraries like Lipgloss and Bubbletea really allow users to build a rich experience nowadays. Really anything from https://charm.land is well-polished and a joy to use.
- Kitty image format works great and allows for Avatars, image previews, etc, which helps immensely make slk feel like a Slack client and not an IRC client.
I really enjoy using Golang to make TUIs and the Charm ecosystem.
> But I think we will swing back to using GUIs
I've been pushing on BubbleTea Kitty and Ghostty quite a bit to hybridize this. The TUI / GUI distinction to me is about task centrism and delivery. There's an appropriate surface and workflow for every task; beyond TUI/GUI sometime it needs to be a VR headset or an immersive room or a literal sandbox.
A demo of this is web-delivery of our BubbleTea TUI examples ('t' toggles between glyph/kitty):
https://nimblemarkets.github.io/ntcharts/demos/heatpicture-p...
The delivery uses our WIP Booba tool, which is Ghostty-based. The CLI tool can be used to remote or embed any TTY program, but was generally built for BubbleTea. https://github.com/NimbleMarkets/go-booba
I've recently made SVG, PDF, SVG, and OpenStreetMap widgets.... https://github.com/NimbleMarkets/ntcharts-svg https://github.com/NimbleMarkets/ntcharts-pdf https://github.com/NimbleMarkets/ntcharts-osm
Right now I'm working on multiple ds4 TUIs using this stack, for example generating SVGs from a prompt and then rendering it in TUI. Another generates CSG object graphs and renders/composites them in terminal. Here's a gist with screenshots:
https://gist.github.com/neomantra/ae47422c8daf7a458212c93992...
The upstream ds4 project is using C for their TUIs. I have done TUIs in C and C++ (and many other languages) and will not go back to that. Really fun engine though and a great place to stick a TUI. I am a Camel furry (https://cameltopia.org) but wouldn't use OCaml to make a TUI either (makes sense for Jane Street of course).
Yep, that's about it. I am making a TUI for non-techies, packing it with Ghostty, and sending it to non-techies to use:
https://github.com/weedonandscott/trolley
Cool idea!
Soooo... lib ghostty supports the kitty (but not sixel) terminal image format.
> But I think we will swing back to using GUIs when we find a performant way of making them, I don't know what it is yet but surely someone is working on this.
I might be missing something here, but wouldn't any UI toolkit that doesn't live within a WebView work?
Yes, and of those, my impression is that there are niche ones that look OK, game engines that look great but take a lot of work, and then there's just TUIs, which look retrocool and run blazing fast, and are really easy to write.
> and are really easy to write.
And, sometimes, all you want is to output text.
> and then there's just TUIs, which look retrocool and run blazing fast, and are really easy to write
I mean, I don't even think that's true. Many TUIs are bloated, dogshit slow, and it's not trivial to write complex TUIs without glitches or flickering. The more people start making TUIs because it's the current fad, the worse they will get.
1 reply →
> But I think we will swing back to using GUIs when we find a performant way of making them
I like this new TUI renaissance as well, but if you wanna see what a symbiotic relationship between GUIs x TUIs could look like you need to see what Emacs does with Orgmode and the whole Org ecosystem of org-agenda, org-roam, etc. Lot's of these TUIs from the awesome are somewhat already inside Emacs.
https://orgmode.org/ https://orgmode.org/manual/Agenda-Views.html
I agree. The only reason I use TUI is because GUI are very slow with electron.
The only software that is as fast as TUI is the Zed IDE. Apparently they use Rust + their own built GUI toolkit with GPU rendering.
And apparently it's tightly coupled with Zed.
> I think mostly this renaissance is partly due to the current bloat of Electron GUIs.
I think it's mostly due to the CLI being much more powerful than a full-blown IDE: when you try to make everything simple (in a menu, accessible with one mouse-click or a shortcut), then semi-advanced things (which haven't been thought of in the IDE) become impossible.
They also compose way more easily with the network: it's much easier to SSH/tmux TUIs than to try to network GUIs. That's very important in this day and age of incessant exploits and the need to run things in VMs to try to prevent exploits from pwning your entire world.
TUIs sadly doesn't entirely solve the bloat issue: look at Claude Code CLI... An Electron app because, as the Pi author mentioned, people at Anthropic thought they were writing a game. A full headless Electron app converted, on the fly, to pretend it's a TUI.
The madness is real (shitload of message of users not happy with characters shown on screen not being those saved to source files: and I've been bit by this) and the bloat issue hasn't been solved.
But in any case you cannot go back to a GUI and not have that problem of GUIs being too restrictive: invariably there shall be a need to chain several simple commands that do one thing and that excel at that one thing and that only become powerful when chained with other commands. GUIs cannot solve that.
LLMs have just proved what many knew all along: that the CLI is more powerful.
Instead of GUIs on the contrary I expect more TUIs, more command line, and more, much more, REPL usage by LLMs and by devs using LLMs.
What I do hope though is that we get more lean TUIs (like Pi by Mario Zechner, all the utils written in Rust etc.) and less madness like "headless Electron converted 60 times per second to a fake TUI".