ThinkTerm

English · 简体中文 · 日本語 · Français · Deutsch

📥 Download

Download here - Get the latest release

🍺 Homebrew (macOS):

brew install --cask roversx/tap/thinkterm

🌐 Website: closex.org/thinkterm

📚 Documentation: docs.closex.org/thinkterm

⭐ Consider starring ThinkTerm!

Your machines fuse into one.

ThinkTerm is an open-source terminal with a built-in multiplexer, written in Rust, built on WezTerm. Its mux server runs your shells, tools, and coding agents; desktop, TUI, and browser clients connect to those sessions. Bring local and remote work into one workspace, and return to it from another device.

Platforms: macOS · Linux · Windows · Web · TUI — iOS and Android in development.

A multiplexer at the core

A terminal multiplexer manages multiple terminal sessions and lets clients attach to them. In ThinkTerm, the mux server owns the sessions, tabs, and split panes. The client displays them and sends your input.

• Detach and return. Disconnecting a client leaves its server-held sessions running. Reconnect later to continue the same shell, build, or agent task. Explicitly closing a pane is a separate action.
• Access the same sessions from different clients. Use the desktop, thinkterm tui, or the browser to connect to the server. Multiple clients can be attached at once; each offers its own interface to the shared sessions.
• Work across machines. Each host runs its own mux server. ThinkTerm Connect brings those remote workspaces into the desktop alongside local work, so you can switch machines from the sidebar. Processes continue to run on their original host.

Session persistence depends on the mux server and its host remaining available; it does not restore running processes after a server restart or host reboot.

Why ThinkTerm

Running several agents across different projects quickly turns a tab bar into a guessing game: which session is working, which needs input, and where did that build finish? ThinkTerm puts the project structure and work status beside the terminal, with local and remote work visible together.

Rust powers ThinkTerm's terminal core, mux server, desktop client, and TUI. The desktop renders through the GPU without Electron or an embedded web view. Built on WezTerm, this native foundation supports workspace organization, persistent remote sessions, and tools for working alongside agents.

Workspaces that follow your work

Local and remote workspaces share the sidebar. Thread status helps distinguish running work, work needing attention, completed work, and idle sessions. The overview displays live terminal previews grouped by Space, so you can find a session without opening every tab.

Built for daily terminal work

• Rust, performance, and memory efficiency. ThinkTerm is built for demanding terminal workflows. Terminal throughput, rendering efficiency, and memory use are ongoing optimization priorities, with the goal of keeping many sessions and agents responsive as they work in parallel.
• Agent status. The Agents panel brings recognized coding agents into one list with their work status and project context. Agent detection and the panel can be disabled in settings.
• Remote sessions. Choose SSH, Mosh, or persistent mux sessions through ThinkTerm Connect. Remote mux sessions support tabs, splits, resizing, and reconnecting. Predictive local echo can reduce perceived typing latency on slower connections.
• Files beside the terminal. Browse project files, preview source with syntax highlighting, and open files in an external editor. Remote file access uses SFTP, with uploads, downloads, and drag-and-drop transfers.
• Notes. Work with Markdown in an Obsidian-compatible Vault, including tables, code blocks, and autosave. The files remain ordinary Markdown in a directory you choose.
• Snippets and plugins. Snippets is built in. Plugins can add sidebar panels to the desktop and browser; the repository includes a Diff plugin for inspecting the adjacent terminal's Git changes. Build your own plugins in Rust with the ThinkTerm SDK. Find plugins others share under the GitHub topic thinkterm-plugin. See the plugin guide for setup and development.
• A capable terminal core. Ligatures, color emoji, true color, hyperlinks, inline images, copy mode, and shell integration come from WezTerm. See the WezTerm feature reference for more terminal capabilities.
• Native desktop settings. Adjust themes, UI font sizes, terminal options, and the renderer. Both the main window and settings support WebGPU and OpenGL, with an OpenGL fallback if WebGPU initialization fails.
• Five interface languages. English, 简体中文, 日本語, Français, and Deutsch.

The CLI also exposes panes to automation: thinkterm cli send-text sends input and thinkterm cli get-text reads terminal output. Agents can use these commands to interact through their terminals. The collaboration notes describe the demonstrated workflow and the limits of terminal input as a messaging mechanism.

Choose how you connect

The clients connect to server-held sessions; their interfaces and feature coverage differ.

Terminal interface

thinkterm tui
thinkterm tui --help

The TUI supports workspace navigation, tabs, splits, resizing, copy mode, and mouse input. Exiting detaches from the server without closing its sessions. Run it from a separate terminal; launching it inside ThinkTerm's own session can trigger the nested-session guard.

Browser access

Enable a listener in Settings → Web, then create an access token for the browser. The mux server serves the client and its assets. Connections away from loopback require HTTPS by default; the browser also needs a secure context to expose WebGPU.

See Browser access for listener setup, tokens, SSH forwarding, and certificate handling.

Mobile development

The iOS and Android apps use native interfaces and the shared mobile core. They connect over SSH to sessions on another machine. They are under active development and are not presented here as released mobile products.

Getting started

For a desktop build on macOS or Linux, install Rust and your platform's build tools, then:

git clone --recursive https://github.com/RoversX/ThinkTerm.git
cd ThinkTerm
./get-deps
cargo build --release -p wezterm -p wezterm-gui -p wezterm-mux-server -p thinkterm-plugin-server

The binaries are written to target/release. See Contributing for the source layout and development workflow. The browser build script builds the separate Web assets; mobile build entry points are ios/build.sh and android/build.sh.

Once the binaries are on your PATH:

thinkterm start              # Open the desktop application
thinkterm tui                # Open the terminal interface
thinkterm connect <name>     # Attach to a configured mux domain
thinkterm cli --help         # Inspect and control mux sessions
thinkterm plugin list        # List available plugins
thinkterm --help             # Show all commands

Documentation and development

• Browser access
• Plugins
• Contributing

Configuration an