Kaku

Kaku implements a GPU-accelerated rendering pipeline inherited from WezTerm but optimized for macOS through native CoreText font rendering instead of cross-platform abstractions. The TermWindow core manages a render loop that converts terminal cell state into GPU commands, with platform-specific code paths for macOS CoreText font metrics and glyph rasterization. This approach reduces latency for high-frequency screen updates while maintaining sub-40MB binary size through feature removal and symbol stripping.

Kaku ships with sensible defaults (JetBrains Mono font at 13pt, opencode color scheme, optimized for low-DPI displays) embedded in the binary, eliminating the blank-slate problem of WezTerm. Configuration follows a three-tier priority system: CLI arguments override ~/.config/kaku/kaku.lua overrides bundled defaults. The Lua configuration system exposes the full wezterm module API (wezterm.action.SplitHorizontal, wezterm.color.parse, event hooks like gui-startup), allowing power users to customize without losing defaults.

Kaku provides clipboard integration that allows terminal applications to read and write the system clipboard via escape sequences (OSC 52 protocol). Toast notifications appear as transient UI elements in the terminal window to provide feedback for actions (e.g., 'Pane split', 'Workspace switched'). The notification system integrates with the rendering pipeline to display toasts without blocking terminal output. Clipboard operations are handled by the platform layer, with macOS-specific code using NSPasteboard for clipboard access.

Kaku provides a configuration TUI (Text User Interface) accessible via kaku config that allows users to interactively edit settings without manually editing Lua files. The TUI presents configuration options in a structured format (e.g., font selection, color scheme, keybindings) and validates changes before writing to ~/.config/kaku/kaku.lua. The TUI integrates with the Lua configuration system, allowing users to preview changes and revert if needed. This approach lowers the barrier to configuration for users unfamiliar with Lua.

Kaku implements workspaces as a grouping mechanism for related windows, tabs, and panes, allowing users to organize work by project or context. Workspaces are named and can be switched via keybindings or command palette. The multiplexer maintains workspace state (open windows, tabs, panes, their layout) during the session. Users can define workspace templates in Lua configuration to automatically create workspaces with specific layouts (e.g., 'frontend' workspace with dev server pane, 'backend' workspace with API server pane).

Kaku bundles and auto-installs a curated zsh plugin suite during first-run initialization (kaku init): z for frecency-based directory navigation, zsh-completions for extended shell completion, zsh-syntax-highlighting for real-time command validation, and zsh-autosuggestions for history-based suggestions. Plugins are copied to ~/.config/kaku/zsh/plugins/ and sourced via shell integration scripts that detect shell type and environment. This approach eliminates the need for users to manually discover, install, and configure productivity plugins.

Kaku integrates an AI assistant (kaku ai command) that analyzes failed shell commands and suggests corrections or alternative approaches. The system captures command exit codes, stderr output, and command context, then sends this to configured AI providers (OpenAI, Anthropic, or local models) to generate contextual suggestions. Integration points include shell integration scripts that hook into command execution and a configuration interface (kaku config) for setting AI provider credentials and model preferences. This capability is designed specifically for AI-assisted coding workflows where developers iterate rapidly.

Kaku implements a multiplexer (Mux) architecture inherited from WezTerm that manages multiple windows, tabs, and panes within a single process. The TermWindow core coordinates rendering and input for all panes, with each pane maintaining independent terminal state (scrollback, cursor position, cell grid). Panes can be split horizontally or vertically via wezterm.action.SplitHorizontal/SplitVertical, and workspaces group related windows and tabs. The multiplexer supports both local panes (running shell processes) and remote panes (SSH connections via wezterm-ssh crate), enabling seamless switching between local and remote environments.

Kaku provides a command palette (accessible via keybinding, typically Cmd+Shift+P) that implements fuzzy search over all available actions (split pane, new tab, switch workspace, etc.). The palette is built into the GUI frontend and integrates with the Lua configuration system, allowing users to define custom actions via wezterm.action bindings. Search uses fuzzy matching to filter actions by name or description, enabling rapid action discovery without memorizing keybindings. The palette also supports command history, allowing users to repeat recent actions.

Kaku exposes a Lua event system through the wezterm module that allows users to hook into terminal lifecycle events (gui-startup, user-var-changed, window-config-reloaded, etc.). Events are defined in the Lua configuration file and receive context about the triggering event (e.g., window object, variable name and value). This enables users to implement custom behavior like auto-loading shell environments, syncing clipboard, or triggering external tools on specific events. The event system integrates with the TermWindow core and multiplexer, allowing events to modify window state or spawn new panes.

Kaku implements a built-in self-update system (kaku update command) that checks for new releases, downloads binaries, and performs in-place updates without requiring package managers or manual downloads. The update system maintains version history and supports rollback to previous versions via kaku reset. Update checks are performed asynchronously and can be configured to run on startup or on a schedule. The system verifies binary integrity via checksums and handles macOS code signing and notarization requirements automatically.

Kaku provides shell integration scripts (in assets/shell-integration/) that detect the user's shell type (zsh, bash, fish) and environment, then configure the shell to work optimally with Kaku. The integration includes first-run setup (kaku init) that installs bundled CLI tools (e.g., z, zsh-completions), configures shell plugins, and sets up environment variables. A state management system (state_common.sh) tracks configuration version and detects when updates are needed. The integration also provides health checks (kaku doctor) to diagnose shell configuration issues.

Kaku supports SSH domains (configured via Lua) that allow users to create named SSH connections and open panes on remote servers as if they were local. The wezterm-ssh crate handles SSH protocol implementation with connection pooling to reuse connections across multiple panes. Remote panes appear in the multiplexer alongside local panes, enabling seamless switching between local and remote environments. The system supports remote file access (e.g., opening files on remote servers) and integrates with the shell integration system to configure remote shells.