uniTerm review: a Wails terminal that folds SSH, RDP, databases and an AI agent into one window

The problem uniTerm solves: one window instead of six connection tools

Most engineers keep a terminal emulator, an SFTP client, a database GUI, a container dashboard and an RDP client open at once. Each has its own connection list, its own credential store, its own keyboard shortcuts. uniTerm's answer is to put all of them behind one connection manager and one tab bar. The README describes it as "A lightweight all-in-one terminal with 30+ protocols" and lists the categories explicitly: remote terminal, local and serial terminal, file transfer, remote desktop, database, containers and server monitor.

The audience is narrow but real. It is for people who move between a Linux box over SSH, a Windows host over RDP, a MySQL instance and a Kubernetes cluster in the course of a day. It is not for someone who only ever opens one SSH session, and it is not for someone who wants a terminal they can script from the outside. The project is a desktop application built with Wails, not a CLI tool, so anything you would normally drive from a shell script is out of reach unless the app exposes it.

How uniTerm is put together: a Go backend behind a Vue frontend

The repository layout tells you most of the architecture. The root holds main.go, app.go and a family of app_*.go files split by concern: app_ai.go, app_container.go, app_database.go, app_file_transfer.go, app_remote_desktop.go and app_terminal.go. Those are the Wails bindings that the frontend calls. The frontend/ directory holds the Vue application, and wails.json is the Wails project descriptor. The primary language listed for the repository is Vue, but the protocol work happens in Go.

go.mod confirms the mechanism rather than merely implying it. Each protocol is a Go library: github.com/pkg/sftp for SFTP, github.com/jlaffaye/ftp for FTP, github.com/cloudsoda/go-smb2 for SMB, github.com/studio-b12/gowebdav for WebDAV, github.com/rhnvrm/simples3 for S3, github.com/unixshells/mosh-go for Mosh, go.bug.st/serial for serial ports, and github.com/creack/pty plus github.com/UserExistsError/conpty for local shells on Unix and Windows respectively. Databases are the same pattern: go-sql-driver/mysql, lib/pq, go-ora, go-mssqldb, go-redis, the official MongoDB driver and gorqlite. Remote desktop is handled through app_remote_desktop.go, and the README notes RDP is Windows only.

Wails v3 is pinned at v3.0.0-beta.16 in go.mod. That is a beta dependency, and it is the single largest structural risk in the project: the desktop shell, the windowing and the Go-to-JavaScript bridge all sit on a pre-release library. Credentials go through github.com/zalando/go-keyring, which means the OS keychain rather than a project-specific vault. Cloud sync uses github.com/go-git/go-git to push an encrypted settings repository to GitHub, GitLab or Gitee, so your sync target is a private repo you own rather than a vendor service.

Installing uniTerm and running a first SSH session

The README's Download section points to the GitHub releases page, and the project publishes tagged releases such as v1.9.2 and v1.9.1 alongside a main-snapshot build. The README does not document a package-manager install (no Homebrew formula, no winget manifest, no apt repository), so the realistic path is either a release artifact or a build from source.

Building from source requires Go and the Wails CLI. The repository carries a Taskfile.yml, and the README's Build from Source section is the reference for the exact task names; the go.mod file pins the toolchain expectation at go 1.26.2. A source build looks like this:

git clone https://github.com/ys-ll/uniterm.git
cd uniterm
go mod download
task build

The build task name comes from the repository's Taskfile.yml; if your environment does not have Task installed, read that file for the underlying wails build command rather than guessing flags. After the build you should have a platform binary in the build output directory.

A first real session is connection-oriented. Open the connection manager, create an SSH entry with host, port, username and either a password or a key, then open it as a tab. The README states that SSH supports password or key authentication and that SSH tunnel port forwarding lets any connection route through an SSH jump host, so a database or RDP entry can be pointed at a bastion rather than at the target directly. From the same tab you can drag it into the content area to split panes, and the README describes dragging panel edges to resize.

If you want to try the AI agent, the README says the sidebar chat takes an Anthropic or OpenAI-compatible API and that commands execute in the active terminal tab. Execution modes are named in the README as bypass, dangerous only, dangerous + write, and confirm all. Start with confirm all. The README does not describe a dry-run mode, and it does not document an undo for a command the agent has already run.

The AI agent's execution modes are the feature and the risk

The autonomous agent is the part of uniTerm that is genuinely different from a terminal emulator with a chat sidebar bolted on. The README describes it as planning, executing, observing results and iterating across multiple rounds of shell commands without manual intervention. Commands run in the active terminal tab, and the agent can be pinned to a specific tab or left to follow whichever tab is focused. Conversations persist per session, and skills are reusable workflows attached with a leading slash in the AI input; the README also says the agent can save new skills itself.

That last detail deserves scrutiny. An agent that can write its own reusable skills is extending its own instruction set, and the README does not describe a review step for a skill the agent creates. Combined with the bypass mode, where the agent runs without confirmation, the blast radius is whatever the connected account can do. The confirm all mode exists precisely because the other modes do not ask. The README presents the modes as a control, which they are, but it does not describe command allowlisting, a sandbox, or a per-connection policy that would cap what the agent can touch even in a permissive mode.

There is also a dependency question the README does not answer. The agent needs an Anthropic or OpenAI-compatible endpoint, which means command context leaves your machine. For a terminal that advertises encrypted cloud sync through your own private repo, the AI path is a different trust model, and the README does not discuss what is sent.

Where uniTerm is the wrong tool

Platform coverage is the first hard limit. The README's platform badge reads Windows, macOS and Linux. There is no Android or iOS build, and the protocol set assumes a desktop: serial ports, RDP and local shells such as PowerShell, CMD, Git Bash and WSL do not map onto a phone. Anyone searching for a mobile terminal should look elsewhere.

The second limit is the beta dependency. Wails v3.0.0-beta.16 is a pre-release, and the project also ships a main-snapshot release alongside tagged versions. A snapshot build is not a stable artifact, and if you adopt one you are tracking main. For a tool that holds SSH keys and database credentials, that is a deliberate trade: newer protocol support in exchange for a shell that may change under you.

The third limit is the all-in-one premise itself. A terminal that also speaks Oracle, MongoDB, SPICE and S3 carries a large dependency surface for any single user. If you need only SSH, a smaller emulator will have fewer moving parts and a shorter path from a security report to a patch. The breadth is the product, and it is also the cost.

Alternatives and the actual difference in approach

The closest comparison is a terminal multiplexer plus separate clients. tmux or Zellij over SSH gives you persistent sessions, split panes and a config file you can version, but nothing for RDP, SFTP browsing or database queries, and no GUI connection manager. uniTerm trades the scriptability and the tiny dependency footprint for a graphical catalog of connections.

On the remote-desktop side, dedicated clients remain the reference implementation for their protocol. uniTerm's RDP support is Windows only per the README, so on macOS or Linux you would still need a separate RDP client, which undercuts the single-window pitch for that protocol specifically.

Against GUI database clients, uniTerm's difference is that the database connection and the SSH tunnel to reach it live in the same connection manager. A standalone database GUI usually requires you to configure the tunnel separately or to run an SSH port forward by hand. That integration is the concrete advantage, and it is also the reason the SSH tunnel feature matters more than the protocol count suggests.

Against web-based terminals, uniTerm's difference is that it is a local desktop application with credentials in the OS keychain via go-keyring, rather than a server-side session your browser connects to. That is a different threat model, not a strictly better one.

Licence, maintenance and what an upgrade costs you

uniTerm is Apache-2.0. That permits commercial use, modification and redistribution, and it includes an explicit patent grant. It also carries notice and attribution obligations: the repository ships a THIRD_PARTY_NOTICES.md and the LICENSE file, and if you redistribute a modified build you need to preserve those notices and state what you changed. This is a description of the licence text, not legal advice; if you plan to ship uniTerm inside a product, have counsel read the notice file.

Maintenance looks current. The last push to main was on 2026-09-10, and the most recent tagged release in the repository is v1.9.2 from 2026-09-04, with v1.9.1 on 2026-08-31. The repository is not archived. Release cadence in that window is roughly weekly, which is fast for a desktop application.

Upgrade cost is dominated by two things. First, the Wails v3 beta pin: moving to a stable Wails v3 when it lands may require frontend and binding changes, and the project's own release notes are the place to check that. Second, the protocol libraries in go.mod are individually versioned, so a breaking change in, say, the MongoDB driver or go-git reaches you through a routine dependency bump. The project publishes both tagged releases and a main snapshot, which means you can choose stability or recency but not both. The README does not document a rollback procedure for a bad upgrade, so keep the previous release artifact before you replace it.

Editorial conclusion

uniTerm suits engineers who already juggle several connection tools and want SSH, SFTP, RDP, database and container sessions in one window, and who accept that the AI agent runs shell commands under a mode you choose. It does not suit anyone who needs Android, because the README lists Windows, macOS and Linux only. Before adopting it, check the release page for the platform you use, read the execution-mode documentation for the AI agent, and confirm whether the project publishes signed binaries or expects you to build from source.

Frequently asked questions

Official sources

1. License: Apache-2.0
2. Project website
3. README
4. Releases
5. ys-ll/uniterm on GitHub