A modern terminal emulator built with Kotlin and Compose Desktop.

BossTerm is a high-performance terminal emulator designed for developers who want a fast, customizable, and feature-rich terminal experience 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.

Features:

• Auto-detects platform (macOS, Linux, Windows) and architecture (x64, ARM64)
• Uses the best installation method (Homebrew → DMG on macOS, Deb → RPM → Snap → JAR on Linux)
• Installs Java 17+ automatically if needed (Windows)
• Creates CLI launcher (bossterm command)
• Supports --version, --uninstall, --dry-run, and --method flags

Common 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 .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

sudo snap install bossterm_*.snap --classic --dangerous

# Download bossterm-*.jar from GitHub Releases
java -jar bossterm-*.jar

git clone https://github.com/kshivang/BossTerm.git
cd BossTerm
./gradlew :bossterm-app:run

• Native Performance - Built with Kotlin/Compose Desktop for smooth 60fps rendering
• Multiple Windows - Cmd/Ctrl+N opens new window, each with independent tabs
• Multiple Tabs - Ctrl+T new tab, Ctrl+W close, Ctrl+Tab switch
• Split Panes - Horizontal/vertical splits with Cmd+D / Cmd+Shift+D
• Themes - Built-in theme presets (Dracula, Solarized, Nord, etc.) with custom theme support
• Window Transparency - Adjustable opacity with background blur effects
• Background Images - Custom background images with blur and opacity controls
• Xterm Emulation - Full VT100/Xterm compatibility
• True Color - Full 256 color and 24-bit true color support
• Mouse Reporting - Click, scroll, and drag support for terminal apps (vim, tmux, htop, less, fzf)
• Full Unicode - Emoji (👨‍👩‍👧‍👦), variation selectors (☁️), surrogate pairs, combining characters
• Nerd Fonts - Built-in support for powerline symbols and devicons
• Inline Images - Display images in terminal via iTerm2's imgcat (OSC 1337)
• Progress Bar - Visual progress indicator for long-running commands (OSC 1337)
• Search - Ctrl/Cmd+F to search terminal history with regex support
• Hyperlink Detection - Auto-detect URLs, file paths, emails with Ctrl+Click to open
• Copy/Paste - Standard clipboard + copy-on-select + middle-click paste + OSC 52
• Context Menu - Right-click for Copy, Paste, Clear, Select All
• Drag & Drop - Drop files onto terminal to paste shell-escaped paths (iTerm2 style)
• Auto-Scroll Selection - Drag selection beyond bounds to scroll through history
• IME Support - Full Chinese/Japanese/Korean input method support
• Visual Bell - Configurable visual flash for BEL character
• Command Notifications - System notifications when long commands complete (OSC 133)
• OSC 7 Support - Working directory tracking for new tabs
• Settings UI - Full GUI settings panel with live preview
• Debug Tools - Built-in terminal debugging with Ctrl+Shift+D
• Welcome Wizard - First-time setup wizard for shell, tools, and AI assistants
• Customizable - JSON-based settings at ~/.bossterm/settings.json

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 "\033]133;A\007"                # Prompt starting
    echo -ne "\033]7;file://${HOSTNAME}${PWD}\007"  # Working directory
}
PROMPT_COMMAND='__prompt_command'
trap 'echo -ne "\033]133;B\007"' DEBUG  # Command starting

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 "\e]133;A\a"                   # Prompt starting
    print -Pn "\e]7;file://${HOST}${PWD}\a"  # Working directory
}
preexec() { print -Pn "\e]133;B\a" }         # Command starting

This enables:

• New tabs inherit working directory from active tab
• System notifications when commands > 5 seconds complete while window is unfocused

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

Settings are stored in ~/.bossterm/settings.json:

{
  "fontSize": 14,
  "fontName": "JetBrains Mono",
  "copyOnSelect": true,
  "pasteOnMiddleClick": true,
  "scrollbackLines": 10000,
  "cursorBlinkRate": 500,
  "enableMouseReporting": true,
  "performanceMode": "balanced",
  "notifyOnCommandComplete": true,
  "notifyMinDurationSeconds": 5
}

BossTerm offers configurable performance optimization via Settings > Performance:

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>")
}

import ai.rever.bossterm.compose.EmbeddableTerminal
import ai.rever.bossterm.compose.rememberEmbeddableTerminalState

@Composable
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)
}

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, and open new splits.

• Endpoint: http://127.0.0.1:7676/ over Server-Sent Events, configurable via Settings → BossTerm MCP → Port.
• Loopback-only: the server binds 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.
• Opt-in: disabled by default. Toggle on under Settings → BossTerm MCP.

1. Open Settings → BossTerm MCP and toggle Enable BossTerm MCP Server. A green "BossTerm MCP on" pill appears in the tab bar.
2. (Optional) Under Exposed Tools, untick any built-in tool you don't want clients to call — toggles apply live.
3. Under Attach to AI CLI, click the button for each AI CLI you want to register the endpoint with. Re-attachment is idempotent and happens silently on subsequent launches.

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()
        }
    }
}

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 embedded-example and tabbed-example 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.

• Kotlin - Modern JVM language
• Compose Desktop - Declarative UI framework
• Pty4J - PTY support for local terminal sessions
• ICU4J - Unicode/grapheme cluster support

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               # Launch in a directory
bossterm new                          # New window
bossterm new-tab                      # New tab in the running BossTerm  (MCP)
bossterm run npm test                 # Run a command in a new tab        (MCP)
bossterm run --split=h tail -f log    # Open a horizontal split and tail  (MCP)
bossterm send $'ls\n'                 # Send to the focused pane           (MCP)
bossterm logs --lines 50              # Dump the last 50 scrollback lines  (MCP)
bossterm attach claude                # Re-register with Claude Code
bossterm mcp status                   # Inspect MCP enabled/port/state
bossterm mcp on | off                 # Toggle settings.mcpEnabled
bossterm config                       # Print path to ~/.bossterm/settings.json
bossterm --help                       # Full usage

Run man bossterm after installation for the complete reference.

Note on local dev usage: the repo-root ./bossterm is a symlink into cli-resources/bossterm, so ./bossterm --version works from a clean git clone. GitHub's "Download ZIP" link does not preserve symlinks (the file materializes as plain text containing the link target). If you've downloaded a zip rather than cloned, run cli-resources/bossterm directly, or git clone the repo.

• Embedding Guide - Embed a single terminal with custom context menus
• Tabbed Terminal Guide - Full-featured tabbed terminal with splits
• BossTerm MCP Server - Expose tabs to MCP clients (Claude Code, Codex, Gemini, OpenCode)
• BossTerm CLI - man bossterm reference (troff)
• Onboarding Wizard - First-time setup wizard for users
• Troubleshooting Guide - Common issues and solutions
• Release Notes - Detailed changelog for each version

Contributions are welcome! Please feel free to submit issues and pull requests.

BossTerm is dual-licensed under:

• LGPLv3
• Apache 2.0

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.

• JediTerm by JetBrains — original inspiration for terminal emulation
• iTerm2 — the beloved macOS terminal, inspiration for many UX features
• Pty4J — PTY library for local terminal sessions
• ICU4J — Unicode and grapheme cluster support

• Terminal protocol description — Xterm control sequences
• Terminal Character Set Terminology and Mechanics — ISO 2022 character sets
• VT420 Programmer Reference Manual — DEC terminal reference
• UTF-8 Demo — Unicode test file
• Control sequences visualization — GNU teseq
• Terminal protocol tests — vttest suite

Built by Risa Labs Inc