Ghostty-Powered Terminal with Split Tabs and AI Programming Notifications for macOS

Introduction

For developers working extensively with AI-powered coding assistants like Claude Code, the standard macOS Terminal application often falls short. When managing multiple concurrent sessions, developers find themselves juggling numerous Terminal windows, creating a cluttered and inefficient workspace.

Consider this common scenario: you submit a complex task to Claude, then switch to other work while waiting. Minutes later, you return to find Claude awaiting your approval on a critical operation—but you missed the notification entirely. Frontend developers face additional friction: after Claude generates code, launching a preview requires yet another context switch to a browser window.

Enter cmux, a revolutionary terminal application designed specifically for modern AI-assisted development workflows. Built on Ghostty's foundation, cmux transforms your terminal from a simple command-line interface into a comprehensive development command center.

The cmux Advantage

Core Features That Transform Your Workflow

cmux introduces a suite of features specifically designed to address the pain points of AI-assisted development:

Notification Ring System:
When new alerts arrive, affected panes display a distinctive blue ring with highlighted tabs. This visual indicator ensures you never miss important notifications from your AI assistants or long-running processes.

Unified Notification Panel:
Rather than scattered alerts across multiple windows, cmux consolidates all notifications in a centralized panel. Jump to any unread notification with a single click, maintaining awareness across all your active sessions.

Integrated Browser:
Perhaps the most transformative feature: a built-in browser that splits alongside your terminal. Control browser behavior through scripts, preview generated code instantly, and eliminate the constant alt-tabbing between terminal and browser windows.

Advanced Tab and Split Management:
Support for both horizontal and vertical splits, complemented by a sidebar displaying branches, pull requests, directory structures, exposed ports, and notification status. Organize complex development environments within a single window.

SSH Workspace Integration:
The cmux ssh command establishes direct remote connections while routing browser traffic through the remote network. Transfer files effortlessly through drag-and-drop functionality.

Claude Teams Support:
Execute cmux claude-teams to launch multi-agent collaboration sessions with native split-screen display. Coordinate multiple AI agents working on different aspects of your project simultaneously.

Browser Data Import:
Seamlessly import browser data from Chrome, Firefox, Arc, and other browsers. Start with existing login sessions and bookmarks immediately configured.

Custom Command Configuration:
Define project-specific operations in cmux.json and access them through the command palette. Standardize common workflows across your team.

Scripting Capabilities:
Full CLI and socket API support for programmatic control of workspaces, panes, and browser instances. Automate complex development workflows.

Native macOS Performance:
Built with Swift and AppKit, cmux delivers fast startup times and minimal resource consumption. GPU-accelerated rendering through libghostty ensures smooth visual performance.

Ghostty Compatibility:
Directly reuse existing Ghostty themes, font configurations, and color schemes. No need to rebuild your terminal aesthetic from scratch.

Comprehensive Keyboard Shortcuts:
Extensive shortcut coverage for workspace management, pane navigation, browser control, and notification handling.

Configuration Guide

Getting Started with Ghostty Configuration

cmux reads its configuration from Ghostty's configuration file, making migration seamless for existing Ghostty users.

Open your configuration file at ~/.config/ghostty/config and add the following settings:

# === Theme Configuration ===
# Automatic light/dark theme switching based on system settings
theme = dark:iTerm2 Dark Background,light:iTerm2 Light Background

# === Shell Integration ===
# Automatic detection and integration with your shell
shell-integration = detect

# === Font Settings ===
font-size = 12
font-thicken = true
adjust-cell-height = 2

# === Window Configuration ===
window-theme = system
window-save-state = always
background-opacity = 0.8
macos-titlebar-style = transparent

# === Mouse Behavior ===
copy-on-select = clipboard
mouse-shift-capture = true
mouse-hide-while-typing = true
cursor-style = bar
cursor-style-blink = true
cursor-opacity = 0.85

# === Scrollback Buffer ===
scrollback-limit = 8388608

# === Quick Terminal ===
quick-terminal-position = top
quick-terminal-screen = mouse
quick-terminal-autohide = true
quick-terminal-animation-duration = 0.2

# === Security Settings ===
clipboard-paste-protection = true
clipboard-paste-bracketed-safe = true

Important: After modifying the configuration file, reload the settings through the menu bar to apply changes.

Installation Process

Install cmux via Homebrew with a single command:

brew install --cask cmux

Note: You may need to add the cmux tap first if it's not already configured in your Homebrew setup.

Comprehensive Keyboard Shortcut Reference

Workspace Management

Interface Navigation

Pane Splitting

Browser Controls

Browser developer tools follow Safari's default keyboard shortcuts, customizable in Settings → Keyboard Shortcuts.

Notification System

Search and Find

Terminal Operations

Window Management

Session Restoration Behavior

What Gets Restored

Upon application restart, cmux preserves your workspace layout and metadata:

• Window, workspace, and pane layout structure
• Working directories for each pane
• Terminal scrollback buffers (best-effort restoration)
• Browser URLs and navigation history

What Doesn't Persist

The following elements are not restored after restart:

• Running processes within terminals (Claude Code sessions, tmux, vim, etc.)
• Active command execution state
• Unsaved editor contents

Notification System Deep Dive

cmux supports desktop notifications, enabling AI agents and scripts to alert you when attention is required. This feature transforms passive terminal sessions into active collaborators that can request your input when needed.

Key capabilities:

• View all pending notifications in a unified interface
• Quickly navigate to the latest unread notification
• Visual indicators highlight panes requiring attention
• Notification history for reviewing past alerts

Practical Usage Scenarios

Scenario 1: AI Code Review
Your AI assistant completes a code analysis and needs your approval before proceeding with refactoring. A notification appears, and clicking it takes you directly to the relevant terminal pane.

Scenario 2: Long-Running Build
A compilation process completes with errors. Instead of constantly monitoring the terminal, you receive a notification when the build finishes, allowing you to work on other tasks in the meantime.

Scenario 3: Multi-Agent Coordination
When using Claude Teams, different agents can send notifications when they complete their tasks or encounter issues requiring human intervention.

Recommended Development Layout

For optimal AI-assisted development, consider this three-pane layout:

Left Pane - Claude Code:
Your primary AI coding assistant, running continuous sessions for code generation, review, and refactoring.

Top-Right Pane - Development Server:
Running npm run dev or equivalent, providing real-time feedback on code changes.

Bottom-Right Pane - Integrated Browser:
Displaying your application preview, automatically refreshing as changes are detected.

This layout eliminates context switching and provides comprehensive visibility into your entire development workflow within a single window.

Enhancing File Management with Yazi

Introduction to Yazi

Yazi (meaning "duck" in Chinese) is a terminal file manager written in Rust, built on non-blocking asynchronous I/O. It delivers efficient, user-friendly, and highly customizable file management directly within your terminal environment.

Installation Requirements

Install Yazi and its dependencies via Homebrew:

brew install yazi ffmpeg-full sevenzip jq poppler fd ripgrep fzf zoxide resvg imagemagick-full font-symbols-only-nerd-font
brew link ffmpeg-full imagemagick-full -f --overwrite

Shell Integration (Optional)

For seamless integration, add the following function to your ~/.zshrc file:

function y() {
    local tmp="$(mktemp -t "yazi-cwd.XXXXXX")" cwd
    command yazi "$@" --cwd-file="$tmp"
    IFS= read -r -d '' cwd < "$tmp"
    [ "$cwd" != "$PWD" ] && [ -d "$cwd" ] && builtin cd -- "$cwd"
    rm -f -- "$tmp"
}

After saving, execute source ~/.zshrc to activate the integration. You can now launch Yazi by simply typing y instead of the full yazi command.

Configuration Files

Yazi utilizes three primary configuration files:

1. yazi.toml - General configuration settings
2. keymap.toml - Keyboard shortcut bindings
3. theme.toml - Color scheme customization

Basic Configuration Setup

Create ~/.config/yazi/yazi.toml with the following settings:

[mgr]
show_hidden = true
show_symlink = true

This configuration displays hidden files and shows symlink target paths.

Custom Key Bindings

Create ~/.config/yazi/keymap.toml to customize keyboard shortcuts:

[[input.prepend_keymap]]
on = "<Esc>"
run = ["close", "mgr:escape --filter"]
desc = "Close input and cancel the filter"

Essential Keyboard Shortcuts

Navigation

File Operations

Path Copying

Search and Filter

Practical Integration Scenarios

Scenario 1: Terminal-Based Development Environment

Combine cmux and Yazi to create a fully terminal-based development environment:

1. cmux provides the multi-pane workspace with integrated browser
2. Yazi handles file navigation and management within terminal panes
3. Claude Code runs in dedicated panes for AI assistance

This setup enables you to write code, manage files, run applications, and preview results—all without leaving your terminal environment.

Scenario 2: Remote Development Workflow

Leverage cmux's SSH capabilities for seamless remote development:

1. Connect to remote servers using cmux ssh
2. Browser traffic routes through the remote network
3. Access remote files through Yazi integration
4. Run AI assistants directly on remote infrastructure

Scenario 3: Multi-Project Management

Organize multiple projects within cmux workspaces:

• Each workspace represents a different project
• Sidebar displays project-specific information
• Notifications keep you informed across all projects
• Quick switching between contexts

Conclusion

The combination of cmux and Yazi represents a paradigm shift in terminal-based development workflows. By addressing the specific challenges of AI-assisted programming—notification management, context switching, and file navigation—these tools create a cohesive environment that enhances productivity without sacrificing the power and flexibility of terminal-based workflows.

The learning curve is minimal for existing Ghostty users, and the productivity gains become apparent almost immediately. Whether you're a solo developer managing multiple projects or part of a team coordinating complex development tasks, cmux and Yazi provide the infrastructure needed to work more efficiently in the age of AI-assisted coding.

Start with the basic configuration, explore the keyboard shortcuts gradually, and customize the setup to match your specific workflow. The investment in learning these tools pays dividends in reduced context switching, improved awareness, and streamlined development processes.