# Termora: A Kotlin/JVM Terminal Emulator and SSH Client With a Plugin System

> Termora is a cross-platform terminal emulator and SSH client built in Kotlin/JVM, shipping a key manager, SFTP browser and a plugin catalogue. It is still in beta, and its dual AGPL-3.0 or commercial licence is the first thing to check before adopting it.

**TermoraDev/termora** — Termora is a terminal emulator and SSH client for Windows, macOS and Linux.

- Repository: https://github.com/TermoraDev/termora
- Website: https://termora.app
- Stars: 3,829 · Forks: 231
- Language: Kotlin
- License: not declared
- Published: 2026-09-23 · Updated: 2026-09-23 · Language: en
- Canonical page: https://hysenlabs.com/projects/termoradev-termora

## What Termora is, and who it is built for

Termora is a terminal emulator and SSH client for Windows, macOS and Linux. It is written in Kotlin/JVM and partially implements the XTerm control sequence protocol, which is the specification that defines how terminal programs drive cursor movement, colours and other screen behaviour. The README states that the long-term goal is full platform support, including Android, iOS and iPadOS, via Kotlin Multiplatform. That goal is stated as a direction, not as something already delivered.

The intended user is someone who manages remote hosts from a desktop and wants more than a bare terminal window. The feature list includes a built-in key manager, SSH-Agent integration, X11 forwarding, GUI-based SFTP file management, system information display, Nvidia GPU usage monitoring and quick command shortcuts. Hosts are organised in a tree-like hierarchy similar to folders, can carry tags, and can be imported from other tools. If your workflow is a terminal multiplexer over a plain shell, Termora adds a layer you may not want. If you regularly move files between server A and server B and edit remote files, that layer is the point.

## How the terminal, host tree and plugins fit together

The architecture visible in the repository is a Kotlin/JVM desktop application with a plugin directory at the top level alongside src/, docs/ and the Gradle build files. The README lists the plugins individually: Geo for host geolocation, Sync for pushing settings to Gist or WebDAV, WebDAV for connecting to WebDAV storage, Editor for the built-in SFTP file editor, SMB for Server Message Block connections, S3 for S3 object storage, and separate connectors for Huawei OBS, Tencent COS and Alibaba OSS. A link points to a full plugin list on the project site.

File transfer is a first-class feature rather than a side panel. The README states that transfers can run directly between server A and server B, that folders transfer recursively, and that up to 6 concurrent transfer tasks are supported. File editing follows the same model: saving an edited file auto-uploads it, folders can be renamed, large folders can be deleted with rm -rf, permissions can be edited visually, and new files and folders can be created. Hosts connect to this: a host entry can be opened with the transfer tool.

The design trade-off is that the plugin catalogue is broad but shallow in the documentation. The README names each plugin and what it connects to, and says nothing about how plugins are installed, versioned or isolated from the host application. A plugin that syncs settings to Gist or WebDAV touches credentials and configuration, and the README does not describe how those are stored. Treat that as an open question to resolve before you point Sync at a real account.

## Installing Termora and opening your first host

The README gives four distribution channels. On macOS, Homebrew installs the cask:

```bash
brew install --cask termora
```

On Windows, WinGet installs the package:

```bash
winget install termora
```

The README also links the latest GitHub release and a Microsoft Store listing, which are the routes for a direct download or a store-managed install. There is no documented Linux package command in the README, so Linux users should start from the releases page.

Once installed, the workflow the README describes is: add a host, optionally place it in the tree-like hierarchy and assign tags, then open it as a terminal session or hand it to the transfer tool. The README does not walk through the add-host dialog field by field, so the exact form is something you discover in the application. If you prefer to run from source, the development section recommends the JetBrainsRuntime JDK and gives a single Gradle task:

```bash
./gradlew :run
```

That task runs the application locally from the checkout. The README does not document a build-and-package task for producing your own installer, so packaging is not covered by the instructions available.

## Beta status and the limits the README does not answer

The release history is the clearest signal about maturity. The three most recent releases listed are 2.0.0-beta.16, 2.0.0-beta.15 and 2.0.0-beta.14. Every one carries a beta label. The version file at the repository root and the default branch named 2.x are consistent with a project that has not yet declared a stable 2.0 line. The last push to the repository was on 2026-09-04, so development is current, but current activity is not the same as a stable release.

Beyond the beta label, several things a prospective user would want to know are simply not in the README. There is no documented rollback path if a settings sync overwrites a working configuration. There is no statement about where the key manager stores private keys, whether they are encrypted at rest, or how they are protected on each platform. There is no compatibility matrix for the XTerm control sequences that are implemented versus those that are not, only the statement that the implementation is partial. There is no documented Linux install command. None of this makes Termora unusable, but each is a question you answer by reading the source or testing on a throwaway host rather than by reading the documentation.

The X11 forwarding and Nvidia GPU monitoring features are also worth framing carefully. The README lists both as features without stating platform constraints. X11 forwarding from a Windows or macOS client depends on an X server being present, and GPU monitoring depends on Nvidia tooling being reachable on the remote side. The README does not spell out either dependency.

## How Termora differs from terminal multiplexers and web SSH clients

The closest alternatives in the same search space are desktop SSH clients such as Termius and WindTerm, and the terminal multiplexer route represented by tools like trzsz-ssh. The difference is where the state lives. A multiplexer keeps sessions inside a shell on the remote or local machine, and everything you do is a command. Termora puts hosts, keys, transfers and file editing into a GUI backed by a plugin system, so the state lives in the application's own configuration, which is exactly why it can offer Gist or WebDAV sync and why the sync plugin carries risk.

Self-hosted web SSH clients sit on the other side. They run as a service you reach through a browser, which means no per-workstation install and a shared access point. Termora is the opposite: a desktop application you install per machine through Homebrew, WinGet or the Microsoft Store. If your requirement is access from an arbitrary browser, Termora does not address it. If your requirement is a native client with local key storage and drag-and-drop file transfer, the web model is the one that does not fit.

Termux is a different category again. It is a terminal environment for Android, while Termora's Android support is listed only as a long-term goal through Kotlin Multiplatform. Anyone searching for Termora on Android should read that sentence in the README before downloading anything.

## Licence, maintenance and upgrade cost

Termora is distributed under a dual-licence model. The README states that you may choose AGPL-3.0, under which you can use, distribute and modify the software, or a proprietary licence obtained by contacting the author for closed-source or proprietary use. The practical consequence is that if you embed Termora in a product you ship under a non-AGPL licence, the AGPL-3.0 option is not the one you want, and the commercial route requires a conversation with the author. This is a description of what the README says, not legal advice; the terms themselves govern.

The repository contains a THIRDPARTY file, which is where third-party component notices would live. The README does not summarise those components or their licences, so anyone doing a licence review should read that file directly rather than rely on the README's dual-licence paragraph.

Upgrade cost is shaped by the beta cadence. Releases are labelled beta, and the gap between the listed releases is measured in months rather than days. Settings sync through the Sync plugin means your configuration may live in Gist or WebDAV, so a version upgrade interacts with remote state you control, and the README does not describe a migration or backup procedure for that. The safe posture is to keep a copy of your host list and keys outside the application before upgrading across beta versions.

## Conclusion

Termora suits engineers who want a GUI SSH client with SFTP, a key manager and a plugin catalogue on Windows, macOS or Linux, and who are comfortable running beta software. It is the wrong pick if you need a headless or web-based client, or if AGPL-3.0 is incompatible with how you ship your own product and you have not arranged the commercial licence. Before adopting, verify the current release channel on the releases page and confirm which licence applies to your use.

## FAQ

### Is Termora free to use?

Termora is distributed under a dual-licence model. You may use it under AGPL-3.0, or obtain a proprietary licence from the author for closed-source or proprietary use.

### Which platforms does Termora run on?

The README lists Windows, macOS and Linux. Android, iOS and iPadOS are described as a long-term goal to be reached through Kotlin Multiplatform, not as current support.

### How do I install Termora on macOS or Windows?

The README gives brew install --cask termora for Homebrew and winget install termora for WinGet. It also links the latest GitHub release and a Microsoft Store listing. No Linux install command is documented.

### Does Termora support file transfer between two servers?

Yes. The README states that transfers can run directly between server A and server B, that folders transfer recursively, and that up to 6 concurrent transfer tasks are supported.

### Can I build Termora from source?

The development section recommends the JetBrainsRuntime JDK and gives a single command, ./gradlew :run, to run the application locally. The README does not document a packaging task for producing installers.

## Sources

- [Issues](https://github.com/TermoraDev/termora/issues)
- [Project website](https://termora.app)
- [README](https://github.com/TermoraDev/termora/blob/2.x/README.md)
- [Releases](https://github.com/TermoraDev/termora/releases)
- [TermoraDev/termora on GitHub](https://github.com/TermoraDev/termora)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/termoradev-termora