tmux-palette: Best CLI Tools for tmux power users in 2026

What Is tmux-palette?

tmux-palette is a command palette for tmux by eduwass, built on Bun with no runtime dependencies, and it is one of the best CLI tools for tmux power users. It gives terminal-heavy developers a fast way to search actions, launch popups, jump between windows, and switch palettes from a single key binding.

It keeps the codebase to roughly 2k LOC as of Feb 2026, ships with 12 built-in themes, and stores user config in ~/.config/tmux-palette/*.json so local edits survive repo updates. The design is opinionated: interactive, file-based, and easy to audit instead of a sprawling tmux framework.

Quick Overview

Who Should Use tmux-palette?

• Daily tmux users who want a searchable command launcher instead of memorizing dozens of key chords.
• Indie hackers and backend developers who keep lazygit, htop, btop, gh, or log tailing in the same terminal workflow.
• Platform and DevOps engineers who need a small, auditable way to expose panes, windows, sessions, and scripted actions from one binding.
• People who want local customization without editing source files, because tmux-palette keeps user JSON in ~/.config/tmux-palette/.

Not ideal for:

• Teams that want a full tmux session templating system for booting entire project layouts.
• Users on older tmux versions that cannot support popup behavior reliably.
• Developers who hate JSON and want all config expressed as shell-only scripts.

Key Features of tmux-palette

• Fast startup on Bun — tmux-palette runs on Bun and has no runtime dependencies, which keeps the binding snappy enough for muscle-memory use. That matters because a palette you hesitate to open becomes dead weight in a terminal workflow.
• JSON-backed user config — user changes live in ~/.config/tmux-palette/*.json, so local palettes, hidden entries, sizing, and themes persist across repo updates. This is the right trade-off for people who prefer explicit config over opaque state.
• Custom palettes from shell sources — a palette can point at a shell command that prints JSON or one item per line. That makes it trivial to generate entries from gh pr list, docker ps, npm run, or any script that already emits terminal-friendly output.
• Popup tool launcher — actions like { "popup": "htop" } can open tools such as btop, lazygit, log tails, or fzf scripts inside a tmux popup. This removes the context switch between the shell and a separate TUI launcher.
• Theme picker with live preview — tmux-palette includes 12 built-in themes, including Dracula, Tokyo Night, Catppuccin, Gruvbox, Nord, and Solarized. Live preview matters because terminal contrast and cursor visibility are easy to get wrong by reading a config file alone.
• Mobile-aware sizing — it can auto-fullscreen on narrow terminals, which is useful on iOS terminal apps like Moshi and Blink. That keeps the palette usable on constrained screens instead of forcing a tiny centered panel.
• Hide built-ins cleanly — hidden.json lets you declutter the default command list without patching the source. If your tmux setup is already opinionated, suppressing unused actions makes the palette feel faster and less noisy.

tmux-palette vs Alternatives

Pick tmuxinator when the problem is booting a known project layout with panes, commands, and sessions every time. Pick tmuxp when you want declarative session specs and the center of gravity is repeatable startup, not interactive command discovery.

Pick fzf-based scripts when you want the lightest possible shell utility and you are happy to wire your own tmux actions. Pick tmux-palette when you want a focused in-terminal launcher that is still small enough to audit and customize in one sitting.

If you are pairing tmux with AI-assisted config work, Claude Code Canvas and Claude Context Mode fit the same edit-and-test loop because tmux-palette keeps everything in local JSON. For broader automation across multiple repositories and workflows, OpenSwarm is the better companion than a single-purpose tmux plugin.

How tmux-palette Works

tmux-palette is built around a simple model: a key binding launches a shell entrypoint, the entrypoint reads per-user JSON files, and the UI presents a searchable list of actions inside tmux. The core abstraction is an item that resolves to a tmux command, a shell command, a popup tool, or another palette, which keeps the surface area small and easy to reason about.

That architecture is why the project is practical for daily use. Bun gives it quick startup, tmux gives it the terminal popup and session control layer, and JSON gives you predictable config diffs instead of hidden state. The tool also supports scriptable sources, so a palette can be synthesized from live output rather than a hand-maintained static list.

bind -n C-Space run-shell "~/Sites/tmux-palette/bin/tmux-palette.sh"

That binding makes the palette open with Ctrl+Space, which is a sensible no-prefix key for people who want a Raycast-like interaction model inside tmux. Once the palette opens, typing a few letters narrows the command list, and hitting Enter dispatches the selected action immediately.

If you want an AI pass to set up the binding and write your first config files, Claude Code Canvas or Claude Context Mode can help draft the JSON while you keep the manual approval loop tight. That fits tmux-palette’s design philosophy: small executable pieces, explicit config, and no source fork required.

Pros and Cons of tmux-palette

Pros:

• Very fast launch path thanks to Bun and the lack of runtime dependencies.
• Low config blast radius because user settings live under ~/.config/tmux-palette/ instead of in a patched repo.
• Works with real terminal workflows like lazygit, htop, btop, gh, and log tailing through popup actions.
• Scriptable input model supports JSON and line-oriented output, which makes it easy to connect to existing shell tooling.
• Small enough to audit at roughly 2k LOC, which matters if you want to understand what runs in your terminal.
• Theme and sizing controls give it enough polish to be usable across desktop terminals and narrow mobile clients.

Cons:

• Beta status means some churn is still possible, so teams that want a frozen API should be cautious.
• tmux 3.4+ is the practical baseline, which excludes older environments from the best popup experience.
• JSON can be verbose for users who prefer ad hoc shell functions or pure .tmux.conf bindings.
• It is not a session templating engine, so it will not replace tmuxinator or tmuxp for project bootstrapping.
• Custom shell sources require discipline, because a flaky script will become a flaky palette item.

Getting Started with tmux-palette

git clone https://github.com/eduwass/tmux-palette ~/Sites/tmux-palette
cd ~/Sites/tmux-palette
bun install
printf '%s\n' 'bind -n C-Space run-shell "~/Sites/tmux-palette/bin/tmux-palette.sh"' >> ~/.tmux.conf
tmux source-file ~/.tmux.conf

After that, press Ctrl+Space inside tmux to open the palette and try the default commands first. The initial config lives in ~/.config/tmux-palette/*.json, so your next step is usually adding a custom command palette, a theme.json, or a hidden.json file rather than editing the repo itself.

If you prefer TPM, you can install tmux-palette as a plugin instead of cloning manually, but the direct install path above is the fastest way to verify that Bun, tmux popup support, and your key binding all work together. Once it opens, build one small custom item first, such as lazygit in a popup or a gh pr list launcher, so you can validate the full dispatch loop end to end.

Verdict

tmux-palette is the strongest option for tmux power users who want an interactive command launcher when they run tmux 3.4+ and are fine with JSON config. Its main strength is the combination of Bun-fast startup and local-only customization; the caveat is beta-level surface area. Recommend it if tmux is already your daily shell and you want fewer memorized keybindings.