Docs

Install

Install is the published binary; development is a build from a checkout. The features are the same in both, on every platform: only the shell the Terminal tab runs and the installer differ.

macOS and Linux

One command. It downloads the release binary for your OS and architecture into ~/.local/bin. Add --with-zsh to put that folder on PATH.

Windows

Run this in Windows Terminal. It downloads bento.exe into %LOCALAPPDATA%\bento, adds that folder to your user PATH, and checks that the binary runs. Open a new Windows Terminal and type bento.

Develop

macOS and Linux:

go test ./...
make build
./bento
sh scripts/install.sh --from-source

Windows, in Windows Terminal:

go test ./...
go build -o bento.exe ./cmd/bento
.\bento.exe
.\scripts\install.ps1 -FromSource

go run ./cmd/bento is the quickest loop anywhere: it compiles to a temp directory, so PATH and the checkout stay untouched. --from-source and -FromSource install the checkout itself, which is how a branch is tried before a release exists. go install ./cmd/bento also works, but writes to go env GOPATH's bin, which may not be on PATH.

Options

• --with-zsh adds the PATH export and a bento function to ~/.zshrc, without touching your prompt.
• --no-zsh is the default: the binary only.
• --from-source on macOS and Linux, -FromSource on Windows: build the checkout instead of downloading a release.
• BENTO_INSTALL_DIR changes the install directory; on Windows, so does -InstallDir.
• -NoPath installs bento.exe without editing your user PATH.
• BENTO_REPO points the installer at a fork; BENTO_REPO_URL changes the clone URL the source build uses.

Shortcuts

In the Terminal tab every printable key goes to the prompt, including q; tab still moves between boxes. While editing, printable keys type. The about overlay from , also carries chips for the project on GitHub, the command list, quit, and close; a click runs one.

ctrl+p filters the project's files as you type; enter opens the selection. ctrl+f finds in the open file; enter or ↑ ↓ steps through matches, esc closes.

Editing

e edits the open text file and ctrl+s saves it. Arrows move the caret, enter splits a line, backspace and delete remove and join lines, home and end jump within a line, and tab inserts four spaces. Printable keys type.

The file's tab shows ● while the buffer differs from the file, ✓ after a save, and save failed when the write fails. esc leaves the editor and keeps unsaved text in the preview, where ctrl+s still saves it.

The + new file tab, or n, opens a path prompt and puts the new file straight into the editor; parent directories are created. Every write stays inside the project. A binary file, a commit, and a patch are read-only.

Changes

History's Changes tab lists every path git reports, in order, with its two porcelain columns. enter or a click opens the patch in Main, and the tab title carries the number of changed paths.

M   staged             M   unstaged
MM  staged and unstaged
A   added              ??  untracked
R   renamed, old → new
UU  unmerged

Staged and unstaged changes are shown together, and an untracked file gets a generated new-file patch. A clean tree says so.

Terminal

Build's Terminal tab runs a typed line through your shell inside the project root: $SHELL -c, falling back to /bin/sh, on macOS and Linux; %COMSPEC% /C, falling back to cmd.exe, on Windows. enter runs, ↑ ↓ recall earlier lines, esc clears the prompt and then returns to Build, and ctrl+c stops a running command or clears the prompt.

Output is captured as text: colour, cursor, and erase sequences are dropped so a command like clear cannot touch Bento's own screen. The scrollback is separate from the Build output, and starting a command stops the previous one.

Full-screen programs such as vim or top are not supported; the tab is for one-shot commands. Pipes, globs, and builtins work because the line goes through your shell.

Builds

Automatic mode reads the project and offers:

• package.json scripts, Makefile targets, and gradlew tasks
• go.mod: test, build, and vet; Cargo.toml: test, build, check, and run
• pyproject.toml: python -m pytest, and a build when one is declared

a switches to a shorter manual list, enter runs the selected command, r reruns it, and c cancels the process group. The output streams under the list.

Detected commands run directly, without a shell, so pipes, globs, and builtins belong in the Terminal tab.

Layout

╭──────────────────────────╮ ╭────────────────────╮
│ ≡ main.go  + new file    │ │ ≡ Files            │
│  1 │ package main        │ │ ▾ internal         │
│  2 │                     │ │   ≡ ui             │
│  3 │ func main() {       │ ├────────────────────┤
│  4 │     run()           │ │ History  Changes   │
│  5 │ }                   │ │ ↑1 ↓0 · ● 2        │
│ ↑↓←→ · e edit · ? keys   │ │ ↑↓ · ←→ tab        │
╰──────────────────────────╯ ╰────────────────────╯
╭─────────────────────────────────────────────────╮
│ ▶ Build  Terminal  auto                         │
│ $ go test ./...                                 │
│ ✓ done                                          │
│ ↑↓ pick · enter run · a · r · c · ←→ · ?        │
╰─────────────────────────────────────────────────╯
 ⎇ main  ↑1 ↓0  ● staged 0  ● unstaged 2

• Main: the open file, commit, or patch, with the source caret.
• Files: the project tree, with hidden and vendor folders skipped.
• History: commits on the branch and the working-tree changes, as tabs.
• Build: detected commands and the terminal, as tabs.

Click a box or a tab label to focus and switch; a click in Main puts the caret on that line and toggles a fold marker. The wheel scrolls the box under the pointer. Focus starts on Files, tab cycles the boxes, and the window needs at least 72 × 22 cells.

Missing git, an empty tree, no detected commands, and a clean working tree each say so in place.

Releases

A release is a tagged vX.Y.Z GitHub release with a binary for each platform and a checksum file. The installer picks the right asset and checks it before replacing your copy; only when one is missing, or when you ask for a source build, does it build with Go.

bento_darwin_arm64
bento_darwin_amd64
bento_linux_arm64
bento_linux_amd64
bento_windows_amd64.exe
bento_windows_arm64.exe
SHA256SUMS

Notes are the changelog from each merged pull request, so a release page reads as a short list of what changed. Every merged pull request publishes a release: a feature bumps the minor version, a fix or chore bumps the patch, and a breaking change bumps the major (the minor while the project is 0.x).

Latest release →

About

Bento is a single Go binary built on Bubble Tea, Lip Gloss, and Chroma. It draws its own lagoon palette, so your terminal theme does not change how it looks.

It runs in the macOS Terminal and Windows Terminal, with Menlo or SF Mono on macOS and Cascadia Mono or Consolas on Windows: rounded boxes, no Nerd Font, no braille spinners. Linux uses the same build. Every platform gets the same panes, keys, and features; only the shell the Terminal tab runs and the installer differ. MIT licensed, contributions welcome.

Source on GitHub →