Bubble Tea: fun, functional and stateful way to build terminal apps

https://github.com/charmbracelet/bubbletea

by ingve • 4 years ago

308 113 4 years ago

One thing that I like about this is the implementation of returning state from the Update function. My only experience with Elm-style architecture is with react / redux which involves meticulously copying pieces of the state object to return two distinct before / after states. Using a Go struct with copy semantics makes this extremely easy and more natural to write in an imperative fashion. One limitation of this is that the model structure can only contain value type (e.g. no pointers, arrays, or maps).

mordechai9000• 4 years ago

Just curious, I'm not familiar with Go. Will it copy the references anyway, meaning both structures now have a pointer to the same object? That's the way it works in other languages I'm familiar with, so you have to be careful about what you copy and how you use it.

kgeist2• 4 years ago

Will it copy the references anyway, meaning both structures now have a pointer to the same object?

Correct. A value copy is a simple shallow copy. Deep copy requires use of reflection (if you don't want to manually manage copying).

arccy• 4 years ago

yes, that's what it does in go

tonyhb• 4 years ago

Yes, but it doesn't actually matter. You can use pointers for models, return the same pointer, and it will re-render fine. We do this for our CLI at https://www.inngest.com for creating new serverless functions via a quick walkthrough.

It's actually the `tea.Msg` that causes re-renders. Here's the code: https://github.com/charmbracelet/bubbletea/blob/v0.20.0/tea.....

tea.Msg is, in Redux land, an "action" that triggers some state updates and _always_ triggers a re-render, even if nothing changes.

This is elm-like, but we have to understand the limitations of what we're working with: a terminal with no way of (nicely) updating elements in place. It's essentially an immediate-mode UI, and so it always paints.

kgeist2• 4 years ago

One limitation of this is that the model structure can only contain value type (e.g. no pointers, arrays, or maps)

How does one manage dynamically sized lists of elements, if arrays are disallowed?

simulate-me2• 4 years ago

You can use arrays, but if you want to maintain the Elm-like model of before and after states, then you need to explicitly copy the array into the new state rather than rely on Go copying just the pointer.

mfarstad2• 4 years ago

One of my favorite TUI frameworks. I made https://github.com/mathaou/termdbms with it. A very pleasant experience.

throwawayboise2• 4 years ago

That looks pretty cool, but as most/all DBMSs come with a TUI utility*, what is the advantage?

*(psql, sqlplus, isql, etc....)

mfarstad2• 4 years ago

looks pretty and I think its pretty easy to use. Didn't look at what anyone else had done, tho.

pstuart5• 4 years ago

Ha, I checked it out and it was definitely worthy of a star -- then I noticed I'd already done so. Now I just need to get around to playing with it.

djmips3• 4 years ago

I don't like things that pollute our natural language namespace. Couldn't you have named it something unique?

tsm• 4 years ago

An overwhelming number of programming-related things "pollute our natural language namespace". Off the top of my head:

Ruby, Python, Java, Rails, React, Go, Rust, Elm, Dart, C, C#, Node, Next, Nest, Kafka, LaTeX, bash, fish, cat, Android, Apple, Windows…

I'd be happy to search for this with "bubble tea framework" or "bubble tea tui" or similar and it doesn't bother me.

dvngnt_• 4 years ago

elm?

mrtranscendence2• 4 years ago

I'm having trouble thinking of a single example of a language, library, or piece of technology that is not either an acronym, a name of something that exists, or a combination of such names. Be it an object (Flask), a concept (Scheme), a letter (C), a person (Sinatra), or an animal (Python).

Maybe we need explicit namespacing in English? I'll start saying stuff like "programming languages colon colon ruby" so people can be absolutely sure what I'm talking about.

djmips3• 4 years ago

All Terrible.

bbkane• 4 years ago

I bet you HATE the Go language name.

er4hn• 4 years ago

I call it "Golang". I also _hate_ the use of 1 letter variables in Golang. Give me three and make it easy to search for symbol names in my no-frills editor.

/derail.

neltnerb• 4 years ago

I myself just don't understand why any reasonable person would pick an existing common word for a project in 2022 instead of using the plethora of name generators that can give you something original without even trying.

But like, people that work for Google surely know something about search term collision. Or just don't care about making anything else that has "Go" in the query gets confusing results. Which is an odd stance for Google employees, but none of my business I guess.

Of course it's common anyway, I just don't see why you'd do this to yourself. You either bury your own project, or you are so successful with branding that no one can find what used to have that name. Google can push something hard enough with perfect SEO to make sure that Go the language shows up. A github page?

I mean, it's not Google but: https://duckduckgo.com/?t=ffab&q=go&ia=web First hit -- https://go.dev

https://duckduckgo.com/?t=ffab&q=bubble+tea&ia=places This project is not anywhere near the front page and I can't imagine it ever being. Too many different companies are selling boba tea.

I never really like it when companies use existing common words, but unless you're a huge project or a company that can push the SEO and marketing it's actively burying your work from anyone finding it.

djmips3• 4 years ago

I do.

dangets• 4 years ago

This and the surrounding ecosystem was recently featured on an episode of The Changelog podcast. https://changelog.com/podcast/481

jerodsanto• 4 years ago

Thanks for sharing the show! Here's a transcript for those who'd rather read:

https://changelog.com/podcast/481#transcript

And a couple audiogram snippets from the conversation:

https://www.youtube.com/watch?v=8-5WAKrt9GQ

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

brianzelip• 4 years ago

Hey it’s our Internet friend!

substation132• 4 years ago

This looks like a really cool project, however I have to say that the Go language seems like a terrible match for the Elm architecture.

aarpmcgee• 4 years ago

I’m not overly familiar with Go and would be curious to hear more details about this.

substation132• 4 years ago

Some of the features that make Elm and Elm architecture work so well together:

- Light-weight lambda syntax

- Sum types and records

- Global type inference

- Exhaustive match expressions

- Powerful generics

- Immutability by default

- Partial application / currying

- Modules

- Ecosystem of packages built around pure functions

cosmotic• 4 years ago

Clippy: It looks like you're trying to make a GUI, would you like help with that?

anderspitman4• 4 years ago

I spent a good chunk of time last week looking for a solid cross-platform GUI toolkit. I came to the conclusion that the terminal is the most portable GUI platform available. You can create an app that has windows, buttons, mouse support, etc, statically compile it for Windows, Linux, and Mac, and run it over SSH. The closest you can get to that with real graphics is using a toolkit built on OpenGL, and you'll be forced to dynamically link to X11 or Wayland on Linux.

The achilles heel of terminal UIs is that they can't display images.

Hamcha• 4 years ago

This is so sad. Every time I boot up Plan9 for fun I'm reminded their remoting solution (drawterm) does graphics just fine (since everything is just files, and graphics is done by writing to a software framebuffer device file).

Sure, it's something you can do with SSH via X11 forwarding since forever, but it seems the ecosystem never quite stuck the landing, and now we're here trying to figure out how to make CLI more like GUI for our own sanity.

Maybe we should give it another shot? It seems Windows is trying to do something similar with WSLg to achieve seamless integration of Linux apps within Windows 11 (using RDP under the hood), what is everyone else doing?

oddlama• 4 years ago

I'm actually kind of glad that X11 forwarding didn't stick. TUIs are generally efficiently navigatable using just the keyboard, a property I very much enjoy and frequently miss in "real GUI" apps.

digisign• 4 years ago

They can display images, though the resolution is not very high, even with sixels.

qbasic_forever• 4 years ago

I'd look at Qt or Electron if you need to do cross-platform desktop apps, if for no other reason than accessibility. Sure you can make wacky midnight commander like GUIs in the console, but no screen reader is going to be able to make heads or tails of them and you'll shut out users.

cmroanirgo• 4 years ago

Less modern systems have been running cross platform forever. Eg Free Pascal/lazarus.

TUI/GUI (qt,gtk,cocoa,...) & even has pas2js

shakna• 4 years ago

Curses is screen reader compatible!

JAWS might have dumped all their TUI accessibility features now that they think blind users should only use the GUI, but BRLTTY is based around the console. Orca does assume Gnome and/or a web browser, but it's no worse than usual with a console. (That is to say - I hate Orca, no matter where I'm using it.)

If you're making your own TUIs, there's a few things that curses sneaks in to make things a nicer experience. It uses the start of heading, start of text, file/group/record/unit separators from the invisible portion at the start of the ASCII table, which your sighted users can't see, but things like BRLTTY announce.

(Note: I don't use BRLTTY with an actual Braille display. I use it with espeak.)

aidenn0• 4 years ago

Tk is my goto for cross-platform desktop apps; it's unreasonably good for them. However non-desktop support was essentially nonexistent last time I checked.

ghosty141• 4 years ago

Disagree, there are a ton of differences, especially when it comes to fancier stuff like ncurses provides for example.

QT and Electron are the most capable cross platform tools for building UIs in my opinion. Both have their drawbacks of course, QT is a pain to work with and electron is famous for being not responsive enough for some users

throwawayboise2• 4 years ago

Almost every language has an ncurses library or module. Isn't ncurses fairly cross-platform?

akkartik3• 4 years ago

Lately I'm all in on LÖVE (https://love2d.org). No dynamic linking required, cross-platform, less bloat than mainstream toolkits. Anything it can't do I just accept as a constraint I can't change.

t0astbread3• 4 years ago

Game engines (at least the lightweight ones) seem good for cross-platform graphical apps in general but the idea of redrawing a static GUI at 30 FPS just sounds too inefficient to me.

DrStartup• 4 years ago

Are you sure? https://hpjansson.org/chafa/

kaba03• 4 years ago

Just why? At that point just get a plain old framebuffer and plot individual pixels to it in serial code. How is it better to hack a use-case terminals were not meant to handle? They will have all the other complexities of GUIs still to solve, you just now has a hacky render path to worry about as well.

anderspitman4• 4 years ago

It's cool stuff but unfortunately I need icons.

nelsondev• 4 years ago

Did you consider Web Browsers + Javascript?

IggleSniggle2• 4 years ago

Requires installing a web browser and having access to the computer’s renderer on some level

blooalien• 4 years ago

The cross-platform GUI toolkit I personally prefer is Qt. Bein' I'ma "Python guy" I tend to interact with Qt mainly via PyQt/PySide, but there's handy bindings for a ton of other cross-platform programming languages as well. I've also recently(ish) discovered and been thoroughly impressed by Will McGugan's "Rich" library and the "Textual" TUI library he built for it. Been sprucing up all my terminal output to be more modern using those two lately.

"The achilles heel of terminal UIs is that they can't display images."

That statement is not entirely 100% accurate these days, thanks to some really creative hacks over the years. I'll list a few links where some fun examples live. ;)

[1] https://github.com/atanunq/viu

[2] https://github.com/stefanhaustein/TerminalImageViewer

[3] https://askubuntu.com/questions/97542/how-do-i-make-my-termi...

[4] https://unix.stackexchange.com/questions/35333/what-is-the-f...

anderspitman4• 4 years ago

Qt is solid, no doubt. But it's rather high level and bloated. Plus the company appears to be actively be trying to pull away from open source.

russellendicott• 4 years ago

I'm working on this https://github.com/rendicott/uggly-client

t0astbread3• 4 years ago

Something else that doesn't seem to get a lot of attention in terminal UI is screen reader accessibility. I'm not a regular screen reader user but I've tried a few TUI programs in GNOME Terminal with Orca and it was a mixed bag. Some simple programs were actually usable, more complex layouts not so much. It seems GNOME Terminal outputs the line where the cursor is when it changes so it also depends on if the program puts the cursor somewhere relevant when it finishes updating the screen.

lazyier3• 4 years ago

The cross-platform GUI is WWW.

lilyball5• 4 years ago

Some terminals have custom protocols for displaying images.

The real achilles heel is they're not accessible. There is no terminal protocol for denoting actual objects being drawn in the window such that they can be exposed to accessibility APIs. Standard CLI tools are usable, but TUIs are not.

I have previously seen someone state that for this reason, every TUI program should have an optional CLI mode.

Also, if every UI is a TUI then the OS task switcher becomes useless, terminal programs don't have access to the full set of key modifiers, mouse support is spotty, etc.

ungamedplayer2• 4 years ago

I feel like I've seen TUI's from a completely different angle, including full use of modifier keys , full mouse support, etc.

Its amazing how one persons perspective can completely disagree with anothers.

What did you mean by the "OS task switcher becomes useless" ?

aa-jv• 4 years ago

I've settled in the last few years on using JUCE for all my apps. It has everything I need, and provides more than ample features for adding new GUI elements. I strongly encourage anyone looking for a cross-platform GUI solution to consider JUCE very carefully - it says "for Audio plugins" on the box, but in fact it is perfectly cromulant way of doing 'normal apps' too ..

http://juce.com/

nepeckman2• 4 years ago

I've seen the charm suite on HN before, and everytime I see them I wish they had bindings to other languages. I'm just not interested in Go, but I'm really interested in learning to create ssh applications. Its an application runtime with a lot of potential for the dev space, but almost no quick-start frameworks!

kelvie• 4 years ago

Why not? There's a lot to hate about every language, but one advantage about Go is that it's fairly easy to context switch in/out of, which makes it great for side projects, because it's cognitive load while using it is really low.

Unlike say, Rust. I do love Rust though.

nepeckman2• 4 years ago

I'm only really interested in learning a language if it excites me, or if I'm getting paid to do it. I don't hate Go, and would be fine to learn it on company time for company projects, but there is no spark that would lead me to learn the language on my own. I've written some basic Go, but if I'm using it in personal projects, I'd would have to invest time to understand the ecosystem, runtime, standard lib, best practices, etc.

Klonoar2• 4 years ago

What exactly is hard to switch in/out of Rust, context-wise...?

ebingdom• 4 years ago

I just can't get past the fact that Go doesn't have sum types. As someone who dabbles in category theory, it makes no sense to me that so many popular languages have product types but not their categorical dual. The lack of sum types leads to so many hacks and weird design patterns in the language, like returning two values when you only want the caller to read one of them (that is actually Go's error handling strategy!). To work around the limitations of not having sum types, Go has a "zero" value for every type so you can for example only set the fields relevant to your particular use case, and just hope that no one reads the fields you didn't set.

The problem is that sometimes the zero value is valid, but not special in any way and doesn't make sense as the default. Go has arbitrarily decided that one particular value is special without your blessing or the ability to override it. This leads to bugs in which the zero value shows up in places where you don't expect it, simply because there is some code which doesn't explicitly set it. That's a very easy mistake to make, which makes writing Go an error prone activity.

I shudder to think that there's probably some Go program that deals with money, and a user's balance might be cleared to zero simply because some operation forgot to explicitly set it in some struct.

In order to implement "optional" fields in Go where you want to distinguish between zero (a valid value) and none (a missing value), the common solution is to either put the integer behind a pointer (which can be null) or use some "sentinel" value like -1 to indicate that the value is missing (as long as that sentinel value isn't actually valid in the domain of discourse). These are terrible hacks, but exactly what you'd expect from programmers who spent the majority of their careers writing C.

This design also leads to another kind of issue: sometimes you don't want people to be able to construct values of a particular type without going through a constructor which ensures the relevant invariants hold. This concept ("smart constructors") is widely used in other programming languages, but it's impossible in Go because Go allows anyone to construct an inhabitant of any type simply by declaring a variable of that type.

A simple example of that kind of issue is pointers: in (safe) Rust, references are guaranteed to be non-null, and you use sum types to implement optionality. This is great because you can always dereference a reference and not worry about handling the null case. In Go, all pointer types have that nasty zero value (null), and there's nothing you can do about it. The billion dollar mistake.

I like the fact that Go encourages simplicity, and for the most part the language is fine. But I'm convinced that having every type be pointed rather than supporting proper sum types is actually more complex in terms of the implications it has on writing and reasoning about code. They have mistaken minimality for simplicity.

shirogane86x• 4 years ago

if you need a fun language to learn to make TUIs, haskell has the brick library :) . I've heard very good things about it, it's declarative, only downside is that it doesn't support windows.

ivantse1• 4 years ago

Loved this framework as it helped me build my ssh app idea really quickly (https://github.com/ivantsepp/ssh-slides)! In fact, it pushed me to finally learn golang haha. Would love seeing more and more ssh apps in the wild.

BaconPackets• 4 years ago

We recently did a quick POC with py-cui for a TUI app. It worked pretty well but you quickly see the limits.

This looks really interesting and could be a fun way to get into the Go landscape!

shriphani• 4 years ago

I've been using dialoguer [1], indicatif [2], and colour [3] for the rust ecosystem. Really high quality libraries:

[1] https://docs.rs/dialoguer/latest/dialoguer/ [2] https://github.com/console-rs/indicatif [3] https://docs.rs/colour/latest/colour/

xbar• 4 years ago

Thanks. I keep looking for Bubble Tea alternatives in rust. I am glad to have some handles to a few.

After seeing some recent posts on HN, I've been fantasizing about a Turbo Rust project.

sbeckeriv• 4 years ago

I enjoyed using https://github.com/fdehau/tui-rs on a few side projects.

Bubble Tea: fun, functional and stateful way to build terminal apps

Related Stories