Wave Terminal: an AI-integrated terminal with durable SSH sessions

What Wave Terminal replaces, and for whom

A normal terminal is a single pane of text. When you work on a remote machine you end up with a second window for an editor, a third for a browser, and a fourth for a chat client that has no idea what is on your screen. Wave Terminal's pitch is that these belong in one window, arranged as blocks you drag around.

The target user is someone who spends the day in SSH sessions. The README lists durable SSH sessions that survive connection interruptions and restarts, a graphical editor for remote files, and inline previews for markdown, images, video, PDFs, and CSVs. That is a remote-work toolset, not a local one. If you mostly run commands on your own laptop, most of Wave's distinguishing features are irrelevant to you.

The second audience is people who want an AI assistant with access to terminal context. Wave AI reads terminal output and scrollback, analyzes widgets, and can read, write, and edit files with automatic backups and user approval. It is bring-your-own-key: OpenAI, Claude, Gemini, Azure, Perplexity, or a local model through Ollama and LM Studio. No account is required.

Blocks, wsh, and the Go backend

Wave is an Electron application. The repository has an emain/ directory for the Electron main process, a frontend/ directory, and a Go backend in pkg/ and cmd/ with go.mod declaring Go 1.25.6. The Go side handles the parts that need to touch the operating system: PTYs (github.com/creack/pty), SSH configuration parsing (github.com/kevinburke/ssh_config), known-hosts checking (github.com/skeema/knownhosts), and SQLite storage (github.com/mattn/go-sqlite3). A gorilla/websocket dependency suggests the frontend and backend talk over a WebSocket rather than through Electron IPC alone.

The user-visible unit is the block. A block is a terminal, an editor, a browser, or an AI chat panel, and the README describes a quick full-screen toggle for any block. Command Blocks isolate and monitor individual commands, which is a different idea from a plain shell prompt: each command gets its own tracked region of output.

The wsh command system is how you script the workspace. The README describes it as managing your workspace from the CLI and sharing data between terminal sessions, with wsh file for copying and syncing files between local and remote SSH hosts, and wsh ai for piping output or attaching files to the assistant. This is the part worth understanding before you adopt Wave, because it is what makes the app scriptable rather than just clickable. The README does not document the full wsh surface; it points at docs.waveterm.dev instead.

Installing Wave Terminal on macOS, Windows, or Linux

The README does not give per-platform commands. It says platform-specific instructions are on docs.waveterm.dev/gettingstarted and that you can install directly from www.waveterm.dev/download. So the honest answer to how to install Wave Terminal is: get the build from the download page, and follow the platform instructions in the docs. What the README does specify is the floor for each platform.

macOS 11 or later on arm64 or x64. Windows 10 1809 or later on x64. Linux with glibc 2.28 or later, which the README names as Debian 10, RHEL 8, and Ubuntu 20.04, on arm64 or x64. The wsh helper has a different set of requirements and a much older Linux kernel floor: kernel 2.6.32 or later on x64, 3.1 or later on arm64. That matters if you intend to run wsh on a remote host, because the remote machine's kernel and libc are what constrain you, not your laptop's.

If you want to build it yourself, the README points at BUILD.md and does not repeat the steps. The package.json shows the toolchain: electron-vite for development and builds, electron-builder for packaging, and a postinstall script at ./postinstall.cjs. The scripts are dev, start, build:dev, and build:prod. The version field in package.json reads 0.14.5, matching the latest release tag.

A first session: connecting and using wsh

The README describes one-click remote connections with full terminal and file system access, but it does not print a command for creating them. The concrete, documented surface is wsh, so that is the safest place to start. The README states that wsh ai can pipe output or attach files directly from the command line, which gives you a way to send a command's output to the assistant without copying it by hand. The README does not print the exact invocation, so the pipe shape below is the documented idea rather than a copied example.

The file side is better specified in prose. The README says wsh file copies and syncs files between local and remote SSH hosts. Combined with the built-in editor and the inline previews for markdown, images, video, PDFs, and CSVs, the intended loop is: connect to a host, open a remote file in the editor or preview it, edit, and sync back.

For AI, you configure a provider rather than authenticate against a Wave account. The README lists OpenAI, Claude, Gemini, Azure, and Perplexity as hosted options, and Ollama and LM Studio as local ones. API keys go into secure secret storage that uses native system backends, and the README notes those secrets are accessible across SSH sessions. The README does not document the key names or the settings file format, so the place to look is the Wave AI documentation linked from the README.

Where Wave Terminal is the wrong tool

The first limitation is the one the README states plainly: Wave AI command execution is listed as coming soon, with approval. If your reason for wanting an AI terminal is to have the model run commands for you, that capability is not in the current release according to the README. File operations are available; command execution is not.

The second is the platform floor. glibc 2.28 excludes older enterprise distributions that are still in service. A plain terminal emulator runs almost anywhere; Wave does not.

The third is weight. This is an Electron app with a Go backend and a SQLite database. It will not feel like a native terminal, and on a machine where you want a single fast window, the block model and the browser engine are overhead you are paying for and not using.

The fourth is maturity. The version is 0.14.5 and the README describes the AI credits as a free beta. The repository's last push was on 2026-04-16, which is five months before today's date, so the codebase has not moved recently even though the project is not archived. The README also does not document rollback for file edits, though it does state that AI file operations make automatic backups.

Finally, the README does not describe a plugin API. If you need to extend your terminal with third-party plugins, that is not a capability the material claims.

Wave Terminal compared with Warp and Windows Terminal

The closest comparison people search for is Wave Terminal versus Warp. Both are AI-integrated terminals, and the README does not discuss Warp, so any difference here has to come from what Wave documents about itself. Wave's stated position is open source under Apache-2.0, model-agnostic with bring-your-own-key, and explicitly no accounts required. That is the axis to compare on: whether you can run the assistant against a local model through Ollama or LM Studio, and whether the terminal itself is something you can read and modify.

The Windows Terminal comparison is different. Windows Terminal is a terminal emulator with tabs and panes, and the README's Windows support is one platform among three rather than the focus. Wave's Windows build requires Windows 10 1809 or later, and the wsh helper requires Windows 10 or later. If all you want is tabs, panes, and a fast renderer on Windows, Wave's editor, browser, and AI chat are weight with no payoff.

The comparison that actually decides it is against your existing setup: a terminal emulator plus tmux plus VS Code Remote. That combination gives you persistent remote sessions and remote file editing, which overlaps heavily with Wave's two strongest features. Wave's difference is that the arrangement, the previews, and the AI context live in one window instead of three. Whether that is worth an Electron app is the real question, and the README cannot answer it for you.

Licence, releases, and what upgrades cost

Wave Terminal is licensed under Apache-2.0, and the NOTICE and ACKNOWLEDGEMENTS.md files at the repository root exist for attribution. Apache-2.0 permits commercial use and modification and includes a patent grant. If you redistribute Wave or a modified build, the licence's notice and attribution conditions apply to the files you ship. That is a description of the licence text, not legal advice; read LICENSE and NOTICE yourself if redistribution is on the table.

The release cadence is visible in the tags. v0.14.5 shipped on 2026-04-16, preceded by v0.14.5-beta.2 and v0.14.5-beta.0 on 2026-04-15 and 2026-04-16, and package.json carries the same 0.14.5 version. The beta tags sitting a day or two before the stable tag suggest a short stabilization window. The last push to the default branch was on 2026-04-16, so the repository has been quiet since that release.

The upgrade cost is the usual one for a 0.x app: expect the settings schema and the wsh surface to move. The repository has a schema/ directory and a db/ directory with golang-migrate in the dependency list, which implies database migrations run on upgrade. Back up your local Wave data before a major version jump, and check RELEASES.md for the release you are moving to, since the README does not document downgrade paths.

Editorial conclusion

Adopt Wave if you work across remote SSH hosts and want an editor and browser in the same window as your shell, and you are comfortable with a young Electron app on a 0.x version. Skip it if you need a lightweight terminal, a stable plugin API, or a terminal that runs on older Linux distributions, since glibc 2.28 is the floor. Before committing, verify that your SSH config and host keys are picked up correctly, and test whether a dropped connection actually resumes the way the README describes.

Frequently asked questions

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes