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

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

• Embedding Guide - Embed a single terminal with custom context menus
• Tabbed Terminal Guide - Full-featured tabbed terminal with splits
• 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