{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-tw93--kaku","slug":"tw93--kaku","name":"Kaku","type":"repo","url":"https://x.com/hitw93/status/2040587400582443362?s=46","page_url":"https://unfragile.ai/tw93--kaku","categories":["coding"],"tags":["ai-coding","macos","rust","serial","terminal","terminal-app","terminal-emulator","vibe-coding"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"inactive","verified":false},"capabilities":[{"id":"github-tw93--kaku__cap_0","uri":"capability://automation.workflow.gpu.accelerated.terminal.rendering.with.macos.coretext.integration","name":"gpu-accelerated terminal rendering with macos coretext integration","description":"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.","intents":["I need a terminal that renders text smoothly without lag during rapid output","I want native macOS font rendering that respects system font settings","I need a lightweight terminal binary that doesn't bloat my system"],"best_for":["macOS developers who spend hours in the terminal and notice rendering latency","teams migrating from iTerm2 or Terminal.app who want GPU acceleration without bloat"],"limitations":["macOS-only — no Linux or Windows support despite WezTerm's cross-platform heritage","GPU acceleration requires Metal-capable hardware (2012+ Macs)","CoreText integration means font rendering behavior differs from WezTerm on other platforms"],"requires":["macOS 10.13+","GPU with Metal support"],"input_types":["terminal escape sequences","ANSI color codes","Unicode text"],"output_types":["rasterized GPU-rendered frames","pixel-perfect terminal display"],"categories":["automation-workflow","terminal-emulation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-tw93--kaku__cap_1","uri":"capability://automation.workflow.zero.configuration.bundled.defaults.with.lua.based.overrides","name":"zero-configuration bundled defaults with lua-based overrides","description":"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.","intents":["I want to open a terminal and start coding immediately without configuration","I need sensible defaults that work for AI-assisted coding workflows out of the box","I want to override specific settings via Lua without rewriting the entire config"],"best_for":["developers new to terminal customization who want immediate productivity","teams standardizing on a terminal with consistent defaults across machines","solo developers who value zero-setup experience over maximum customization"],"limitations":["Lua configuration only — no TOML, YAML, or JSON alternatives","Bundled defaults are opinionated (JetBrains Mono, opencode theme) and may not match all preferences","Configuration priority system adds complexity if users expect simple file-based config"],"requires":["Lua 5.4 runtime (bundled with Kaku)","~/.config/kaku/ directory writable by user"],"input_types":["Lua configuration files","CLI arguments"],"output_types":["terminal behavior configuration","keybinding mappings","color scheme definitions"],"categories":["automation-workflow","configuration-management"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-tw93--kaku__cap_10","uri":"capability://automation.workflow.clipboard.and.toast.notification.system","name":"clipboard and toast notification system","description":"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.","intents":["I want terminal applications to copy output to my clipboard","I need visual feedback when I perform terminal actions","I want to paste from my system clipboard into terminal applications"],"best_for":["developers using terminal tools that rely on clipboard integration (e.g., tmux, vim)","teams using Kaku with custom tools that need clipboard access","developers who want visual feedback for terminal actions"],"limitations":["Clipboard integration requires OSC 52 support in terminal applications; older tools may not work","Toast notifications are transient and may be missed if user is not looking at terminal","macOS-specific implementation; behavior may differ on other platforms"],"requires":["Terminal applications that support OSC 52 escape sequences","macOS system clipboard access (typically available)"],"input_types":["OSC 52 escape sequences","action events"],"output_types":["clipboard data","toast notifications"],"categories":["automation-workflow","ui-interaction"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-tw93--kaku__cap_11","uri":"capability://automation.workflow.configuration.tui.with.interactive.settings.editor","name":"configuration tui with interactive settings editor","description":"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.","intents":["I want to change terminal settings without editing Lua files","I need a guided interface to configure Kaku","I want to preview configuration changes before applying them"],"best_for":["developers new to Kaku who are unfamiliar with Lua","teams standardizing on Kaku with non-technical users","users who prefer GUI configuration over file editing"],"limitations":["Configuration TUI may not expose all Lua configuration options; advanced customization still requires file editing","TUI is CLI-based and may be difficult to use on slow terminals or with accessibility tools","Changes made via TUI overwrite manual Lua edits; users must choose between TUI and file editing"],"requires":["Terminal with TUI support (most modern terminals)","~/.config/kaku/kaku.lua writable by user"],"input_types":["interactive menu selections","text input for settings"],"output_types":["updated Lua configuration file","preview of changes"],"categories":["automation-workflow","configuration-management"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-tw93--kaku__cap_12","uri":"capability://automation.workflow.workspace.based.project.organization.with.persistent.layout","name":"workspace-based project organization with persistent layout","description":"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).","intents":["I want to organize my work into separate projects without opening multiple terminal windows","I need to quickly switch between different development contexts","I want to define workspace templates that auto-create panes for specific projects"],"best_for":["developers working on multiple projects simultaneously","teams using Kaku with standardized workspace templates","developers who want project-based organization without external tools"],"limitations":["Workspace state is not persisted across application restarts; workspaces must be recreated on startup","No built-in workspace templates; users must define templates in Lua","Workspace switching may be slow if workspaces contain many panes"],"requires":["Kaku GUI running","Lua configuration for workspace templates (optional)"],"input_types":["workspace names","workspace template definitions"],"output_types":["organized windows and panes","workspace-specific layouts"],"categories":["automation-workflow","project-organization"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-tw93--kaku__cap_2","uri":"capability://automation.workflow.pre.configured.shell.plugin.suite.with.frecency.based.navigation","name":"pre-configured shell plugin suite with frecency-based navigation","description":"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.","intents":["I want shell productivity features (smart cd, completions, syntax highlighting) without manual setup","I need my shell to suggest commands based on my history","I want to navigate directories faster using frecency instead of typing full paths"],"best_for":["developers switching to Kaku who want immediate shell productivity without plugin management","teams standardizing on a shell environment with consistent plugins across developers","solo developers who value convenience over manual plugin curation"],"limitations":["zsh-only — bash, fish, and other shells not supported","Plugin suite is fixed and curated by Kaku maintainers; users cannot easily swap plugins","Frecency algorithm in z plugin may not match all navigation patterns (e.g., projects organized by date rather than frequency)"],"requires":["zsh shell installed and set as default","~/.config/kaku/zsh/plugins/ writable by user","kaku init command executed at least once"],"input_types":["shell commands","directory paths","command history"],"output_types":["command suggestions","directory completions","syntax-highlighted command line"],"categories":["automation-workflow","shell-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-tw93--kaku__cap_3","uri":"capability://planning.reasoning.ai.assisted.error.recovery.and.command.suggestion","name":"ai-assisted error recovery and command suggestion","description":"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.","intents":["I want the terminal to suggest fixes when my command fails","I need AI to explain error messages and propose solutions","I want to configure which AI provider (OpenAI, Anthropic, local) handles error recovery"],"best_for":["solo developers and small teams using AI-assisted coding workflows","developers new to command-line tools who benefit from AI-generated explanations","teams with standardized AI provider contracts (e.g., OpenAI API keys)"],"limitations":["Requires API credentials for external AI providers (OpenAI, Anthropic) or local model setup","Error recovery suggestions are only as good as the AI model's training data; may not handle domain-specific tools well","Latency: AI suggestion generation adds 1-5 seconds per failed command depending on model and network","Privacy concern: stderr and command context are sent to external AI providers unless using local models"],"requires":["API key for OpenAI, Anthropic, or compatible provider","Network connectivity for cloud-based AI providers","kaku config command executed to set AI provider and credentials"],"input_types":["shell command text","command exit code","stderr output","command context (working directory, environment)"],"output_types":["AI-generated error explanations","suggested command corrections","alternative command suggestions"],"categories":["planning-reasoning","ai-assistance"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-tw93--kaku__cap_4","uri":"capability://automation.workflow.multiplexer.based.window.tab.and.pane.management","name":"multiplexer-based window, tab, and pane management","description":"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.","intents":["I want to split my terminal into multiple panes without opening new windows","I need to organize related work into tabs and workspaces","I want to SSH into a remote server and have it feel like a local pane"],"best_for":["developers who work with multiple services simultaneously (frontend, backend, database)","DevOps engineers managing multiple remote servers from one terminal","teams using Kaku as a replacement for tmux or screen"],"limitations":["Multiplexer state is not persisted across application restarts — no session recovery like tmux","Remote panes (SSH) require wezterm-ssh crate which may have different behavior than native SSH","Pane synchronization (sending same input to multiple panes) not mentioned in architecture; may not be supported"],"requires":["Kaku GUI running (multiplexer is GUI-only, not available in CLI mode)","SSH credentials for remote panes (if using SSH domains)"],"input_types":["keybindings for split/tab actions","workspace names","SSH connection strings"],"output_types":["multiple independent terminal panes","tab bar showing open tabs","workspace organization"],"categories":["automation-workflow","terminal-multiplexing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-tw93--kaku__cap_5","uri":"capability://automation.workflow.command.palette.with.fuzzy.search.and.action.binding","name":"command palette with fuzzy search and action binding","description":"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.","intents":["I want to discover available terminal actions without memorizing keybindings","I need to quickly switch between workspaces or open new tabs","I want to define custom actions and access them via fuzzy search"],"best_for":["developers who prefer discoverability over memorization","teams standardizing on Kaku with custom actions defined in shared Lua configs","power users who want rapid action access without reaching for the mouse"],"limitations":["Command palette is GUI-only — not available in CLI mode","Fuzzy search performance may degrade with very large action sets (100+ custom actions)","No built-in action categorization or grouping; all actions appear in a flat list"],"requires":["Kaku GUI running","keybinding configured for command palette (default: Cmd+Shift+P on macOS)"],"input_types":["fuzzy search query","keybinding trigger"],"output_types":["filtered action list","executed action result"],"categories":["automation-workflow","ui-interaction"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-tw93--kaku__cap_6","uri":"capability://automation.workflow.lua.based.event.system.with.lifecycle.hooks","name":"lua-based event system with lifecycle hooks","description":"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.","intents":["I want to run custom code when Kaku starts up","I need to sync my terminal state with external tools (e.g., tmux, shell environment)","I want to trigger actions based on changes to terminal variables"],"best_for":["power users who want to extend Kaku with custom automation","teams with complex terminal workflows that require event-driven behavior","developers migrating from tmux or screen who need custom event handling"],"limitations":["Lua event handlers are synchronous; long-running handlers block the GUI","No built-in event persistence — events are re-evaluated on each startup","Limited event types compared to full terminal multiplexers like tmux"],"requires":["Lua 5.4 knowledge to write event handlers","~/.config/kaku/kaku.lua configuration file"],"input_types":["Lua event handler code","event context (window, variable, etc.)"],"output_types":["modified terminal state","spawned panes or windows","external tool invocations"],"categories":["automation-workflow","scripting"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-tw93--kaku__cap_7","uri":"capability://automation.workflow.self.update.system.with.version.management.and.rollback","name":"self-update system with version management and rollback","description":"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.","intents":["I want Kaku to update itself without manual intervention","I need to rollback to a previous version if a new release breaks my workflow","I want to check for updates and see what changed"],"best_for":["solo developers who want frictionless updates without package manager overhead","teams deploying Kaku across multiple machines and needing centralized version management","developers who want to test new features and rollback quickly"],"limitations":["Self-update is macOS-only (no Linux or Windows support)","Update checks require internet connectivity; offline environments cannot update","Rollback only works if previous versions are cached locally; very old versions may not be available"],"requires":["macOS 10.13+","Internet connectivity for update checks and downloads","Write permissions to Kaku.app bundle (typically /Applications/)"],"input_types":["kaku update command","kaku reset command"],"output_types":["updated Kaku binary","version information","changelog"],"categories":["automation-workflow","version-management"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-tw93--kaku__cap_8","uri":"capability://automation.workflow.shell.integration.with.environment.detection.and.tool.installation","name":"shell integration with environment detection and tool installation","description":"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.","intents":["I want my shell to be automatically configured for Kaku on first run","I need to install CLI tools and plugins without manual setup","I want to diagnose shell configuration issues"],"best_for":["developers new to Kaku who want automated shell setup","teams standardizing on Kaku with consistent shell environments across machines","developers who want to verify their shell configuration is correct"],"limitations":["Shell integration is zsh-primary; bash and fish support may be incomplete","First-run setup (kaku init) modifies shell configuration files (~/.zshrc, ~/.bashrc); users should review changes","State tracking system may not detect all configuration changes; manual reset may be needed"],"requires":["zsh, bash, or fish shell installed","~/.config/kaku/ directory writable by user","kaku init command executed at least once"],"input_types":["shell type detection","environment variables","configuration version"],"output_types":["configured shell environment","installed CLI tools","health check results"],"categories":["automation-workflow","shell-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-tw93--kaku__cap_9","uri":"capability://tool.use.integration.ssh.domain.support.with.remote.file.access.and.connection.pooling","name":"ssh domain support with remote file access and connection pooling","description":"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.","intents":["I want to SSH into a server and have it feel like a local pane","I need to manage multiple SSH connections without opening separate terminal windows","I want to open files on remote servers directly from Kaku"],"best_for":["DevOps engineers managing multiple remote servers","developers working with cloud-based development environments","teams using Kaku as a replacement for separate SSH clients"],"limitations":["SSH domain configuration requires Lua knowledge; no GUI for adding SSH connections","wezterm-ssh crate may have different behavior than native SSH (e.g., different key handling)","Connection pooling may cause issues if remote servers have strict connection limits","Remote file access is limited; full remote editing requires external tools like VS Code Remote"],"requires":["SSH credentials (key or password) configured in Lua","Network connectivity to remote servers","SSH server running on remote machines"],"input_types":["SSH domain configuration (Lua)","SSH credentials","remote file paths"],"output_types":["remote panes in multiplexer","remote shell sessions","remote file access"],"categories":["tool-use-integration","remote-access"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":41,"verified":false,"data_access_risk":"high","permissions":["macOS 10.13+","GPU with Metal support","Lua 5.4 runtime (bundled with Kaku)","~/.config/kaku/ directory writable by user","Terminal applications that support OSC 52 escape sequences","macOS system clipboard access (typically available)","Terminal with TUI support (most modern terminals)","~/.config/kaku/kaku.lua writable by user","Kaku GUI running","Lua configuration for workspace templates (optional)"],"failure_modes":["macOS-only — no Linux or Windows support despite WezTerm's cross-platform heritage","GPU acceleration requires Metal-capable hardware (2012+ Macs)","CoreText integration means font rendering behavior differs from WezTerm on other platforms","Lua configuration only — no TOML, YAML, or JSON alternatives","Bundled defaults are opinionated (JetBrains Mono, opencode theme) and may not match all preferences","Configuration priority system adds complexity if users expect simple file-based config","Clipboard integration requires OSC 52 support in terminal applications; older tools may not work","Toast notifications are transient and may be missed if user is not looking at terminal","macOS-specific implementation; behavior may differ on other platforms","Configuration TUI may not expose all Lua configuration options; advanced customization still requires file editing","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.5625735011972632,"quality":0.25,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.5,"weights":{"adoption":0.3,"quality":0.2,"ecosystem":0.15,"match_graph":0.3,"freshness":0.05}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"inactive","updated_at":"2026-05-06T15:12:23.810Z","last_scraped_at":"2026-05-03T13:58:34.540Z","last_commit":"2026-05-03T02:41:47Z"},"community":{"stars":4835,"forks":237,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=tw93--kaku","compare_url":"https://unfragile.ai/compare?artifact=tw93--kaku"}},"signature":"DymzJTI3kG1ZuR986wRS6dhFNgoQT+7zQjYb5N2syiNV9GQF9kKT0yWi4ERrwlLbS72DF0ElS18k7355waQRBw==","signedAt":"2026-06-23T00:32:41.687Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/tw93--kaku","artifact":"https://unfragile.ai/tw93--kaku","verify":"https://unfragile.ai/api/v1/verify?slug=tw93--kaku","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}