I am also now curious about alternatives/what differentiates this crate

ratatui has been around for quite a bit. it's what I'll reach out for if I need semi-complex TUIs in Rust fwiw

I think they're saying this crate is why Rust is experiencing a TUI revolution.

Charm would probably say the same for Go.

IMO it's like seeing kids bust out disposable kodak cameras at the bar: generational nostalgia

That's a big question. I think TUIs are great for glue processes, and it doesn't hurt when they look pretty. They're also excellent first projects with composable interfaces. Shell code is such a pain. It's quick and dirty, but there are a lot of footguns. The main challenge is reducing the friction of making a TUI to the point where it's easy to execute an idea, and a lot of frameworks do this really well. Add the proliferation of LLMs on top, and maybe that could explain it?

The terminal remains an extremely compelling computing environment in spite of its limitations and fifty years of technical debt. As anachronistic as arcane escape codes and box drawing characters seem in $CURRENT_YEAR, the fact remains that nothing has arisen to fill its niche.

TUI libraries have sufficiently abstracted away the low-level quirks of terminal rendering that the terminal has become something like a canvas[0] available in the IDE with no extensions. This is quite a nice DevX if you want to display the state of an app that does something to data, without writing the necessary plumbing to pipe that data to a browser and render it.

[0] https://github.com/NimbleMarkets/ntcharts/blob/main/examples...

In addition to other comments, it's the only real way to make a usable GUI-like experience over SSH.

I think that a lot of people here at HN have had bad web interfaces and GUIs inflicted on them for a long time, that a TUI is a welcome change and a big improvement. TUIs are limited, which make it hard to create great interfaces; but those limits also make it hard to create really bad interfaces. Also the TUI is genuinely good at simple-to-moderate complexity software. For an example, try out Midnight Commander.

> What is the renewed interest?

We just don’t have good desktop GUI platforms anymore. Qt and GTK are massive beasts, Windows changes theirs every 4 years (and no one wants to be tied to a single platform anyway), we don’t want to deal with Electron, and writing your own GUI from scratch is hard.

Terminals just got good lately and it’s way easier to make something higher quality in them than as a GUI. It’s just too hard to make a good small desktop app.

It’s the same reason why it’s easier to make something look great with LEGO than if you want to mold clay. I’d also wager that devs today on average know more about good UX than devs did back in the 80s when clunky terminal apps used to be made.

They're easier to program and seamlessly integrate into the terminal. That's basically it, other than that they're worse than normal GUIs. Also, GUI frameworks aren't that mature in Rust in particular.

I don't care much about forms and windows in the command line (I've had enough of turbo vision back in the 90s), but I don't think I am alone in wanting to see some progress bars and stats for long running processes. So 2% of these libraries is actually pretty useful.

High-level languages that compile to single binaries, and very good TUI frameworks (maybe inspired by Python Textual?) for them.

> What is the renewed interest?

For me, often, it’s an escape for a GUI world taken over by out-of-control “design” tenets. I value good Ux design concerns, but often working with designers lately feels bureaucratic, at times cargo culting, and overly spacious.

It’s like a graphical form of “I didn’t have time to give you a short answer, so I gave you a long one instead”. TUIs force a paucity that often makes for a nice information/pixels ratio.

Rust, following Go's footsteps, has made it very easy to distribute-and-compile from source. They've taken all the pain out of the compiling-from-source pipeline, through "go build" or "cargo build"

Meanwhile, distributions sometimes maintain their plodding rate at package updates (usually handled by distribution volunteers, not the original program's developers), which was developed in an era when building from source was a tedious process where the distribution volunteers provided value.

In effect, build-from-source has taken over "just use the distribution package".

I also have this question!

I starred Posting[1] but haven't yet got around to trying it.

[1]: https://news.ycombinator.com/item?id=40926211

Edit: here's another one: https://github.com/LucasPickering/slumber

I like smaller more focused tools on the terminal. You can make these all work together pretty reasonably with a little glue. Hurl, mitmproxy, httpie with http-prompt. I tend to prefer mitmproxy sessions and massaging that with Python/curl as needed for repeating and tweaking. User friendly is relative, but these tools work well. Python for tweaking http streams in mitmproxy is powerful and rather friendly for what you get in return. Mitmproxy lets you easily save flows with a bit of Puthon glue to output httpie commands giving history, and you can save mitmproxy sessions.

Kulala nvim plugin or emacs rest client

xh has sessions. https://github.com/ducaale/xh

the cursive tui library does some html rendering

https://sr.ht/~ireas/cursive-markup-rs/

the whole cursive library strikes me as very html-like in layout

Browsh [0] - it runs firefox headless, and renders everything to ascii in the terminal

It's glorious

[0] https://www.brow.sh/