- 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.
> 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).
I might be missing something here, but wouldn't any UI toolkit that doesn't live within a WebView work?
And, sometimes, all you want is to output text.
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.
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
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 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".