4aa9ce489b | ||
---|---|---|
.github | ||
examples | ||
tutorials | ||
.gitignore | ||
.golangci-soft.yml | ||
.golangci.yml | ||
CONTRIBUTING.md | ||
LICENSE | ||
README.md | ||
commands.go | ||
commands_test.go | ||
exec.go | ||
exec_test.go | ||
go.mod | ||
go.sum | ||
key.go | ||
key_test.go | ||
logging.go | ||
logging_test.go | ||
mouse.go | ||
mouse_test.go | ||
nil_renderer.go | ||
nil_renderer_test.go | ||
options.go | ||
options_test.go | ||
renderer.go | ||
screen.go | ||
screen_test.go | ||
signals_unix.go | ||
signals_windows.go | ||
standard_renderer.go | ||
tea.go | ||
tea_test.go | ||
tty.go | ||
tty_unix.go | ||
tty_windows.go |
README.md
Bubble Tea
The fun, functional and stateful way to build terminal apps. A Go framework based on The Elm Architecture. Bubble Tea is well-suited for simple and complex terminal applications, either inline, full-window, or a mix of both.
Bubble Tea is in use in production and includes a number of features and performance optimizations we’ve added along the way. Among those is a standard framerate-based renderer, a renderer for high-performance scrollable regions which works alongside the main renderer, and mouse support.
To get started, see the tutorial below, the examples, the docs, the video tutorials and some common resources.
By the way
Be sure to check out Bubbles, a library of common UI components for Bubble Tea.
Tutorial
Bubble Tea is based on the functional design paradigms of The Elm Architecture, which happens to work nicely with Go. It's a delightful way to build applications.
This tutorial assumes you have a working knowledge of Go.
By the way, the non-annotated source code for this program is available on GitHub.
Enough! Let's get to it.
For this tutorial, we're making a shopping list.
To start we'll define our package and import some libraries. Our only external
import will be the Bubble Tea library, which we'll call tea
for short.
package main
import (
"fmt"
"os"
tea "github.com/charmbracelet/bubbletea"
)
Bubble Tea programs are comprised of a model that describes the application state and three simple methods on that model:
- Init, a function that returns an initial command for the application to run.
- Update, a function that handles incoming events and updates the model accordingly.
- View, a function that renders the UI based on the data in the model.
The Model
So let's start by defining our model which will store our application's state.
It can be any type, but a struct
usually makes the most sense.
type model struct {
choices []string // items on the to-do list
cursor int // which to-do list item our cursor is pointing at
selected map[int]struct{} // which to-do items are selected
}
Initialization
Next, we’ll define our application’s initial state. In this case, we’re defining a function to return our initial model, however, we could just as easily define the initial model as a variable elsewhere, too.
func initialModel() model {
return model{
// Our to-do list is a grocery list
choices: []string{"Buy carrots", "Buy celery", "Buy kohlrabi"},
// A map which indicates which choices are selected. We're using
// the map like a mathematical set. The keys refer to the indexes
// of the `choices` slice, above.
selected: make(map[int]struct{}),
}
}
Next, we define the Init
method. Init
can return a Cmd
that could perform
some initial I/O. For now, we don't need to do any I/O, so for the command,
we'll just return nil
, which translates to "no command."
func (m model) Init() tea.Cmd {
// Just return `nil`, which means "no I/O right now, please."
return nil
}
The Update Method
Next up is the update method. The update function is called when ”things
happen.” Its job is to look at what has happened and return an updated model in
response. It can also return a Cmd
to make more things happen, but for now
don't worry about that part.
In our case, when a user presses the down arrow, Update
’s job is to notice
that the down arrow was pressed and move the cursor accordingly (or not).
The “something happened” comes in the form of a Msg
, which can be any type.
Messages are the result of some I/O that took place, such as a keypress, timer
tick, or a response from a server.
We usually figure out which type of Msg
we received with a type switch, but
you could also use a type assertion.
For now, we'll just deal with tea.KeyMsg
messages, which are automatically
sent to the update function when keys are pressed.
func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
switch msg := msg.(type) {
// Is it a key press?
case tea.KeyMsg:
// Cool, what was the actual key pressed?
switch msg.String() {
// These keys should exit the program.
case "ctrl+c", "q":
return m, tea.Quit
// The "up" and "k" keys move the cursor up
case "up", "k":
if m.cursor > 0 {
m.cursor--
}
// The "down" and "j" keys move the cursor down
case "down", "j":
if m.cursor < len(m.choices)-1 {
m.cursor++
}
// The "enter" key and the spacebar (a literal space) toggle
// the selected state for the item that the cursor is pointing at.
case "enter", " ":
_, ok := m.selected[m.cursor]
if ok {
delete(m.selected, m.cursor)
} else {
m.selected[m.cursor] = struct{}{}
}
}
}
// Return the updated model to the Bubble Tea runtime for processing.
// Note that we're not returning a command.
return m, nil
}
You may have noticed that ctrl+c and q above return
a tea.Quit
command with the model. That’s a special command which instructs
the Bubble Tea runtime to quit, exiting the program.
The View Method
At last, it’s time to render our UI. Of all the methods, the view is the
simplest. We look at the model in its current state and use it to return
a string
. That string is our UI!
Because the view describes the entire UI of your application, you don’t have to worry about redrawing logic and stuff like that. Bubble Tea takes care of it for you.
func (m model) View() string {
// The header
s := "What should we buy at the market?\n\n"
// Iterate over our choices
for i, choice := range m.choices {
// Is the cursor pointing at this choice?
cursor := " " // no cursor
if m.cursor == i {
cursor = ">" // cursor!
}
// Is this choice selected?
checked := " " // not selected
if _, ok := m.selected[i]; ok {
checked = "x" // selected!
}
// Render the row
s += fmt.Sprintf("%s [%s] %s\n", cursor, checked, choice)
}
// The footer
s += "\nPress q to quit.\n"
// Send the UI for rendering
return s
}
All Together Now
The last step is to simply run our program. We pass our initial model to
tea.NewProgram
and let it rip:
func main() {
p := tea.NewProgram(initialModel())
if _, err := p.Run(); err != nil {
fmt.Printf("Alas, there's been an error: %v", err)
os.Exit(1)
}
}
What’s Next?
This tutorial covers the basics of building an interactive terminal UI, but in the real world you'll also need to perform I/O. To learn about that have a look at the Command Tutorial. It's pretty simple.
There are also several Bubble Tea examples available and, of course, there are Go Docs.
Debugging
Debugging with Delve
Since Bubble Tea apps assume control of stdin and stdout, you’ll need to run delve in headless mode and then connect to it:
# Start the debugger
$ dlv debug --headless .
API server listening at: 127.0.0.1:34241
# Connect to it from another terminal
$ dlv connect 127.0.0.1:34241
Note that the default port used will vary on your system and per run, so
actually watch out what address the first dlv
run tells you to connect to.
Logging Stuff
You can’t really log to stdout with Bubble Tea because your TUI is busy occupying that! You can, however, log to a file by including something like the following prior to starting your Bubble Tea program:
if len(os.Getenv("DEBUG")) > 0 {
f, err := tea.LogToFile("debug.log", "debug")
if err != nil {
fmt.Println("fatal:", err)
os.Exit(1)
}
defer f.Close()
}
To see what’s being logged in real time, run tail -f debug.log
while you run
your program in another window.
Libraries we use with Bubble Tea
- Bubbles: Common Bubble Tea components such as text inputs, viewports, spinners and so on
- Lip Gloss: Style, format and layout tools for terminal applications
- Harmonica: A spring animation library for smooth, natural motion
- BubbleZone: Easy mouse event tracking for Bubble Tea components
- Termenv: Advanced ANSI styling for terminal applications
- Reflow: Advanced ANSI-aware methods for working with text
Bubble Tea in the Wild
For some Bubble Tea programs in production, see:
- AT CLI: a utility for executing AT Commands via serial port connections
- Aztify: bring Microsoft Azure resources under Terraform
- Canard: an RSS client
- charm: the official Charm user account manager
- chezmoi: manage your dotfiles across multiple machines, securely
- circumflex: read Hacker News in your terminal
- clidle: a Wordle clone for your terminal
- container-canary: a container validator
- dns53: dynamic DNS with Amazon Route53. Expose your EC2 quickly, securely and privately
- flapioca: Flappy Bird on the CLI!
- fm: a terminal-based file manager
- fork-cleaner: cleans up old and inactive forks in your GitHub account
- fztea: connect to your Flipper's UI over serial or make it accessible via SSH
- gambit: play chess in the terminal
- gembro: a mouse-driven Gemini browser
- gh-b: GitHub CLI extension to easily manage your branches
- gh-dash: GitHub CLI extension to display a dashboard of PRs and issues
- gitflow-toolkit: a GitFlow submission tool
- Glow: a markdown reader, browser and online markdown stash
- gocovsh: explore Go coverage reports from the CLI
- got: a simple translator and text-to-speech app build on top of simplytranslate's APIs
- httpit: a rapid http(s) benchmark tool
- IDNT: batch software uninstaller
- kboard: a typing game
- mandelbrot-cli: Multiplatform terminal mandelbrot set explorer
- mc: the official MinIO client
- mergestat: run SQL queries on git repositories
- Noted: Note viewer and manager
- pathos: pathos - CLI for editing a PATH env variable
- portal: securely send transfer between computers
- redis-viewer: browse Redis databases
- sku: a simple TUI for playing sudoku inside the terminal
- Slides: a markdown-based presentation tool
- Soft Serve: a command-line-first Git server that runs a TUI over SSH
- StormForge Optimize Controller: a tool for experimenting with application configurations in Kubernetes
- STTG: teletext client for SVT, Sweden’s national public television station
- sttr: run various text transformations
- tasktimer: a dead-simple task timer
- termdbms: a keyboard and mouse driven database browser
- ticker: a terminal stock watcher and stock position tracker
- tran: securely transfer stuff between computers (based on [portal][portal])
- Typer: a typing test
- tz: an aid for scheduling across multiple time zones
- ugm: a unix user and group browser
- wander: HashiCorp Nomad terminal client
- wishlist: an SSH directory
Feedback
We'd love to hear your thoughts on this tutorial. Feel free to drop us a note!
Acknowledgments
Bubble Tea is based on the paradigms of The Elm Architecture by Evan Czaplicki et alia and the excellent go-tea by TJ Holowaychuk. It’s inspired by the many great Zeichenorientierte Benutzerschnittstellen of days past.
License
Part of Charm.
Charm 热爱开源 • Charm loves open source