High-performance terminal emulator featuring VT100/Xterm emulation, truecolor 24-bit, mouse and IME support, tabs/windows, search, hyperlink detection, OSC7 working-directory tracking, embeddable component and JSON-configurable settings.
A blazing-fast terminal you can embed, share to any device, and hand to your AI.
| ⚡ |
|---|
A modern terminal emulator built with Kotlin and Compose Desktop — high-performance, deeply customizable, and feature-rich on macOS, Linux, and Windows.
BossTerm delivers industry-leading throughput for developer workflows. Benchmarked against iTerm2, Terminal.app, and Alacritty (December 2025, Latency Mode):
BossTerm ████████████████████████████████████████████████████ 1,645 MB/s ✓
Alacritty ██████████████████████████████████████████████████ 1,633 MB/s
iTerm2 █████████████████████████████████████████████████ 1,599 MB/s
Terminal ████████████████████████████████████████████████ 1,491 MB/s
BossTerm ████████████████████████████████████████████████████ 364 MB/s ✓
iTerm2 ███████████████████████████████████ 255 MB/s
Terminal ██████████████████████████████████ 249 MB/s
Alacritty █████████████████████████████████ 233 MB/s
BossTerm ████████████████████████████████████████████████████ 1.01M ✓
iTerm2 █████████████████████████████████████████████████ 904K
Terminal ████████████████████████████████████████████████ 879K
Alacritty █████████████████████████████████████████████ 829K
BossTerm ████████████████████████████████████████████████ 3.09 ms ✓
Terminal █████████████████████████████████████████████████████ 3.21 ms
iTerm2 ██████████████████████████████████████████████████████ 3.55 ms
Alacritty ███████████████████████████████████████████████████████ 3.72 ms
Full benchmark details: benchmark/README.md | Detailed Results
The universal installer automatically detects your platform and installs BossTerm using the best method available.
| Platform | Command |
|---|---|
Features:
bossterm command)--version, --uninstall, , and flagsCommon operations:
# Install specific version
curl -fsSL https://raw.githubusercontent.com/kshivang/BossTerm/master/install.sh | bash -s -- --version 1.0.80
# Preview without installing
curl -fsSL https://raw.githubusercontent.com/kshivang/BossTerm/master/install.sh | bash -s -- --dry-run
# Force specific method (homebrew, dmg, deb, rpm, snap, jar)
curl -fsSL https://raw.githubusercontent.com/kshivang/BossTerm/master/install.sh | bash -s -- --method dmg
# Uninstall
curl -fsSL https://raw.githubusercontent.com/kshivang/BossTerm/master/install.sh | bash -s -- --uninstall
brew tap kshivang/bossterm
brew install --cask bossterm
Download the latest DMG from GitHub Releases and drag BossTerm to Applications.
# Download the .deb package from GitHub Releases
sudo dpkg -i bossterm_*_amd64.deb
sudo apt-get install -f # Install dependencies if needed
# Download the .rpm package from GitHub Releases
sudo dnf install bossterm-*.x86_64.rpm
sudo snap install bossterm --classic
Or download the .snap file from GitHub Releases and install manually:
sudo snap install bossterm_*.snap --classic --dangerous
Requires Java 17+:
# Download bossterm-*.jar from GitHub Releases
java -jar bossterm-*.jar
git clone https://github.com/kshivang/BossTerm.git
cd BossTerm
./gradlew :bossterm-app:run
BossTerm's default look is the Operator theme — part of the shared BOSS "Operator's Console" visual language: an amber signal (#F2A93B) for the live/now moment on a calm ink floor (#0E1217), with cyan data accents and a MesloLGS mono voice. The tab bar and terminal surface both follow the active theme, and you can switch themes/palettes in Settings.
🎨 Visual styleguide — a self-contained HTML reference for the whole design system's colors / type / components (open it in a browser).
Enable working directory tracking and command completion notifications:
Bash (~/.bashrc):
# OSC 7 (directory tracking) + OSC 133 (command notifications)
__prompt_command() {
local exit_code=$?
echo -ne "\033]133;D;${exit_code}\007" # Command finished
echo -ne
-ne
}
PROMPT_COMMAND=
DEBUG
Zsh (~/.zshrc):
# OSC 7 (directory tracking) + OSC 133 (command notifications)
precmd() {
local exit_code=$?
print -Pn "\e]133;D;${exit_code}\a" # Command finished
print -Pn
-Pn
}
() { -Pn }
This enables:
Settings are stored in ~/.bossterm/settings.json:
BossTerm offers configurable performance optimization via Settings > Performance:
| Mode | Best For |
|---|---|
| Balanced (default) | General use - good balance of responsiveness and throughput |
Note: For
fontName, use a monospace font name installed on your system (e.g., "SF Mono", "Menlo", "JetBrains Mono"). If not set, BossTerm uses the bundled MesloLGS Nerd Font which includes powerline symbols.
BossTerm provides embeddable terminal libraries for Kotlin Multiplatform projects.
Full Documentation: See docs/embedding.md for the complete embedding guide, including custom context menus, focus management, and session persistence.
Maven Central (recommended):
// build.gradle.kts
repositories {
mavenCentral()
}
dependencies {
// Core terminal emulation engine
implementation("com.risaboss:bossterm-core:<version>")
// Compose Desktop UI component
implementation("com.risaboss:bossterm-compose:<version>")
}
JitPack (alternative):
// settings.gradle.kts
dependencyResolutionManagement {
repositories {
maven { url = uri("https://jitpack.io") }
}
}
// build.gradle.kts
dependencies {
implementation("com.github.kshivang.BossTerm:bossterm-core-mpp:<version>")
implementation("com.github.kshivang.BossTerm:compose-ui:<version>")
}
GitHub Packages (requires authentication):
// settings.gradle.kts
dependencyResolutionManagement {
repositories {
maven {
url = uri("https://maven.pkg.github.com/kshivang/BossTerm")
credentials {
username = System.getenv("GITHUB_ACTOR")
password = System.getenv("GITHUB_TOKEN")
}
}
}
}
// build.gradle.kts
dependencies {
implementation("com.risaboss:bossterm-core:<version>")
implementation("com.risaboss:bossterm-compose:<version>")
}
Watch — or hand over — a live terminal to any device, with no cloud relay and no account. BossTerm runs the share server itself; viewers open a link (or scan a QR code) in any browser, or connect from another BossTerm as a native client.
Enable it under Settings → Session Sharing (off by default), then Share from a tab's menu.
Defaults: binds the LAN on port 7677, Cloudflare remote mode, approval required only for public
links.
See docs/session-sharing.md for the full guide — scopes, remote-access setup, the viewer, the native client, the encryption design, and every setting.
BossTerm ships an in-process Model Context Protocol
server that exposes the running terminal to MCP-aware clients (Claude Code,
Codex, Gemini CLI, OpenCode). Clients can enumerate tabs, read scrollback,
search output, capture the last completed command, and — when write tools
are enabled — drive shells, send signals, open new splits, and run
commands in a visible pane while still capturing stdout/stderr and exit
code (run_command — recommended default shell for AI clients).
http://127.0.0.1:7676/ over Server-Sent Events, configurable
via Settings → BossTerm MCP → Port.run_command is exposed by default and ready for explicit use (e.g. "split and
run X"). To make it Claude Code's default shell — preferred over its built-in
Bash for everything — turn on Settings → BossTerm MCP → "Use run_command
as AI clients' default shell" (off by default). With it on, the server's
initialize-time instructions tell Claude Code to prefer run_command (a soft
nudge that applies to the next client connection).
For a hard guarantee that also takes effect instantly, add the user-global
PreToolUse hook described in
docs/mcp-server.md.
BossTerm writes/deletes the ~/.bossterm/mcp.port marker the moment you flip
the setting, and the hook routes Bash calls to mcp__bossterm__run_command
whenever the marker is present — so toggling the setting turns enforcement on or
off per command, with no Claude restart.
Common knobs on BossTermMcpConfig: toolNamePrefix to namespace built-in
tools, allowWriteTools = false for an observe-only build, additionalTools
to register app-specific MCP tools, and customToolDescriptions to override
descriptions of individual built-ins. The
and
modules demonstrate both hooks.
See docs/mcp-server.md for the full reference —
every built-in tool's JSON schema, the manage_tools meta-tool, the
BossTermMcpConfig field-by-field table, and troubleshooting.
A tmux-style background process that owns your terminal sessions, MCP server, and shares so they keep running after you close the GUI — reopen BossTerm and it reattaches to the live sessions. On by default; turn it off under Settings → Session Daemon to fall back to the pre-daemon behavior (in-process MCP/sharing, sessions die with the window), a path that's preserved byte-for-byte.
Manage it under Settings → Session Daemon (toggles take effect after restarting BossTerm). The daemon never stops when you close the GUI — only via Quit daemon, or OS logout.
install.sh installs a bossterm CLI launcher (and a Python helper +
man page) under /usr/local/bin/ or ~/.local/bin/. With no arguments it
launches the GUI; with a positional path it opens that directory.
Beyond launching, the CLI has subcommands that talk to a running BossTerm through the in-process MCP server:
bossterm # Launch the GUI
bossterm ~/Projects/foo
bossterm new
bossterm new-tab
bossterm run npm
bossterm run --=h -f
bossterm send $
bossterm logs --lines 50
bossterm attach claude
bossterm mcp status
bossterm mcp on | off
bossterm config
bossterm --
Run man bossterm after installation for the complete reference.
Note on local dev usage: the repo-root
./bosstermis a symlink intocli-resources/bossterm, so./bossterm --versionworks from a cleangit clone. GitHub's "Download ZIP" link does preserve symlinks (the file materializes as plain text containing the link target). If you've downloaded a zip rather than cloned, run directly, or the repo.
Contributions are welcome! Please feel free to submit issues and pull requests.
BossTerm is dual-licensed under:
You may select either license at your option.
Shivang — shivang@risalabs.ai
BossTerm was originally inspired by JediTerm by JetBrains (authored by Dmitry Trofimov dmitry.trofimov@jetbrains.com and Clément Poulain). The initial version of JediTerm was itself a reworked terminal emulator Gritty, which was in its own turn a reworked JCTerm terminal implementation.
BossTerm has since been completely rewritten from the ground up in Kotlin with Compose Desktop — no JediTerm, Gritty, or JCTerm code remains. Everything was rewritten from scratch with a new rendering engine, new buffer implementation, and new UI framework. A lot of new features were added including split panes, inline images, AI assistant integration, custom platform services, and high-performance incremental snapshot rendering.
Built by Risa Labs Inc
| 📱 Share |
|---|
| 🤖 MCP for AI |
|---|
| 🧩 Embeddable |
|---|
| 1,645 MB/s — edges out Alacritty | Watch & control from any device | Expose tabs to Claude Code & co. | Drop it into your Compose app |
| Benchmark | BossTerm vs iTerm2 |
|---|
| Raw Throughput (1MB) | +43% faster |
| Raw Throughput (5MB) | +24% faster |
| Raw Throughput (50MB) | +3% faster |
| Variation Selectors | +12% faster |
| CJK Characters | +10% faster |
| Powerline | +10% faster |
| htop Simulation | +13% faster |
| Git Diff Simulation | +5% faster |
| Flags Emoji | +3% faster |
curl -fsSL https://raw.githubusercontent.com/kshivang/BossTerm/master/install.sh | bash |
| Windows (PowerShell) | iwr -useb https://raw.githubusercontent.com/kshivang/BossTerm/master/install.ps1 | iex |
| Windows (CMD) | curl -fsSL https://raw.githubusercontent.com/kshivang/BossTerm/master/install.bat -o install.bat && install.bat |
--dry-run--method~/.bossterm/settings.jsoncom.risaboss:bossterm-compose)| Shortcut | Action |
|---|
| Ctrl/Cmd+N | New window |
| Ctrl/Cmd+T | New tab |
| Ctrl/Cmd+W | Close tab/pane |
| Ctrl+Tab | Next tab |
| Ctrl+Shift+Tab | Previous tab |
| Ctrl/Cmd+1-9 | Jump to tab |
| Ctrl/Cmd+D | Split pane vertically |
| Ctrl/Cmd+Shift+D | Split pane horizontally |
| Ctrl/Cmd+Option+Arrow | Navigate between panes |
| Ctrl/Cmd+, | Open settings |
| Ctrl/Cmd+F | Search |
| Ctrl/Cmd+C | Copy |
| Ctrl/Cmd+V | Paste |
| Ctrl+Space | Toggle IME |
BossTerm/
├── bossterm-core-mpp/ # Core terminal emulation library
│ └── src/jvmMain/kotlin/ai/rever/bossterm/
│ ├── core/ # Core utilities and types
│ └── terminal/ # Terminal emulator implementation
├── compose-ui/ # Compose Desktop UI library (embeddable)
│ └── src/desktopMain/kotlin/ai/rever/bossterm/compose/
│ ├── ui/ # Main terminal composable (ProperTerminal)
│ ├── terminal/ # Terminal data stream handling
│ ├── input/ # Mouse/keyboard input handling
│ ├── rendering/ # Canvas rendering engine
│ ├── tabs/ # Tab management
│ ├── window/ # Window management (WindowManager)
│ ├── search/ # Search functionality
│ ├── debug/ # Debug tools
│ └── settings/ # Settings management
├── bossterm-app/ # Main BossTerm application
│ └── src/desktopMain/kotlin/ai/rever/bossterm/app/
│ └── Main.kt # Application entry point
├── embedded-example/ # Example: single terminal embedding
├── tabbed-example/ # Example: tabbed terminal embedding
└── .github/workflows/ # CI configuration
{
"fontSize": 14,
"fontName": "JetBrains Mono",
"copyOnSelect": true,
"pasteOnMiddleClick": true,
"scrollbackLines": 10000,
"cursorBlinkRate": 500,
"enableMouseReporting": true,
"performanceMode": "balanced",
"notifyOnCommandComplete": true,
"notifyMinDurationSeconds": 5
}
| SSH, vim, interactive commands - fastest response time |
| Throughput | Build logs, large files - maximum data processing speed |
import ai.rever.bossterm.compose.EmbeddableTerminal
import ai.rever.bossterm.compose.rememberEmbeddableTerminalState
fun MyApp() {
// Basic usage - uses default settings from ~/.bossterm/settings.json
EmbeddableTerminal()
// With custom settings path
EmbeddableTerminal(settingsPath = "/path/to/settings.json")
// With custom font (via settings)
EmbeddableTerminal(settings = TerminalSettings(fontName = "JetBrains Mono"))
// With callbacks
EmbeddableTerminal(
onOutput = { output -> println(output) },
onTitleChange = { title -> window.title = title },
onExit = { code -> println("Shell exited: $code") },
onReady = { println("Terminal ready!") }
)
// Programmatic control
val state = rememberEmbeddableTerminalState()
Button(onClick = { state.write("ls -la\n") }) {
Text("Run ls")
}
// Send control signals (useful for interrupting processes)
Button(onClick = { state.sendCtrlC() }) {
Text("Stop (Ctrl+C)")
}
EmbeddableTerminal(state = state)
// Session preservation across navigation/visibility changes
val persistentState = rememberEmbeddableTerminalState(autoDispose = false)
if (showTerminal) {
EmbeddableTerminal(state = persistentState)
}
// Terminal process keeps running even when hidden!
// Don't forget to dispose when truly done:
DisposableEffect(Unit) {
onDispose { persistentState.dispose() }
}
// Custom PlatformServices - override process spawning, notifications, etc.
// Uses Kotlin's 'by' delegation to wrap defaults while customizing specific services
val customServices = object : PlatformServices by getPlatformServices() {
val defaults = getPlatformServices()
override fun getProcessService() = object : PlatformServices.ProcessService {
private val delegate = defaults.getProcessService()
override suspend fun spawnProcess(config: PlatformServices.ProcessService.ProcessConfig)
: PlatformServices.ProcessService.ProcessHandle? {
println("Spawning: ${config.command}")
return delegate.spawnProcess(config)
}
}
}
EmbeddableTerminal(platformServices = customServices)
}
cloudflared is fetched automatically, no account).
The tunnel is pre-warmed so the QR is ready the moment you hit Share.#k=…), which browsers
never send to the server — so even a tunnel relay can't read your session. Frames use
per-connection AES-256-GCM, and a short verification code lets both ends confirm the same key.127.0.0.1 and rejects non-loopback
Host headers (DNS-rebinding defense). Any local process running as your
user can reach it while it is enabled.import ai.rever.bossterm.compose.mcp.BossTermMcpConfig
import ai.rever.bossterm.compose.mcp.BossTermMcpManager
import ai.rever.bossterm.compose.mcp.LocalBossTermMcpConfig
import ai.rever.bossterm.compose.mcp.McpTerminalRegistry
import ai.rever.bossterm.compose.settings.SettingsManager
fun main() {
val mcpConfig = BossTermMcpConfig(serverName = "myapp", serverVersion = "1.0")
val mcpScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
val mcpManager = BossTermMcpManager(
registry = McpTerminalRegistry,
settingsManager = SettingsManager.instance,
parentScope = mcpScope,
config = mcpConfig
)
mcpManager.start()
Runtime.getRuntime().addShutdownHook(Thread {
mcpManager.stop()
mcpScope.cancel()
})
application {
CompositionLocalProvider(LocalBossTermMcpConfig provides mcpConfig) {
// Each window that uses TabbedTerminalState must also register
// it with McpTerminalRegistry so the server can see its tabs:
//
// DisposableEffect(tabbedState) {
// McpTerminalRegistry.register(tabbedState)
// onDispose { McpTerminalRegistry.unregister(tabbedState) }
// }
//
// Apps built on the single-terminal EmbeddableTerminal can still
// run the MCP server and register custom tools via additionalTools,
// but the tab-scoped built-ins (list_tabs, send_input, etc.) won't
// see any tabs. See docs/mcp-server.md for the full contract.
MyAppWindows()
}
}
}
embedded-examplerun_command agents don't
die. The next launch mirrors them straight back as tabs.Host guards on every server,
owner-only (0600) discovery/secret files in a 0700 base dir, and a FileChannel.tryLock
single-spawn guard. SESSION-scoped shares are write-isolated to their one session.cli-resources/bosstermgit cloneman bossterm reference (troff)Surfaced from shared tags and platforms — no rankings paid for.