Cmux Customization logo

Cmux Customization

OrganizationPopular
manaflow-ai
cmux-customization

Customize cmux for an end user, including terminal, browser, Markdown, diff, file preview, notes, HTML, and right-sidebar viewers. Use when changing cmux.json actions, custom commands, workspace layouts, plus-button behavior, surface tab bar buttons, Command Palette entries, Dock controls, sidebar and app settings, shortcuts, notifications, browser routing, examples-library presets, or Ghostty-backed terminal preferences.

Overview

Publishermanaflow-ai
Repositorycmux
Skill namecmux-customization
Stars
27.5K
Forks
2.4K
Bundled files
3
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 3 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by manaflow-ai on GitHub. Read the source before you install it.

Installation

Install the Cmux Customization AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/manaflow-ai/cmux/tree/main/skills/cmux-customization
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/manaflow-ai/cmux.git /tmp/cmux
mkdir -p .claude/skills
cp -r /tmp/cmux/skills/cmux-customization .claude/skills/cmux-customization
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Cmux Customization in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Cmux Customization on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Cmux Customization is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

cmux Customization

Keep the user's config intact, prefer schema-backed edits, and validate before reporting completion.

For content viewers, start with the viewer customization matrix. It maps each viewer to the settings, command, or external file that owns its knobs, including explicit fallbacks for viewer types whose template settings have not shipped yet.

Choose the right surface

Want to changeEdit
App preferences (appearance, sidebar, notifications, browser routing, automation, shortcuts, new-workspace placement)~/.config/cmux/cmux.json via the cmux-settings helper
Custom actions, workspace layouts/commands, tab bar buttons, plus-button behavior, Command Palette entries, notification hooks~/.config/cmux/cmux.json globally or .cmux/cmux.json in the project
Dock controls (right-sidebar terminals: logs, test watchers, git TUIs, dev servers, queues, cmux feed tui --opentui).cmux/dock.json or ~/.config/cmux/dock.json; cmux docs dock when available
Terminal rendering and terminal keybindings (fonts, themes, cursor style, copy-on-select, shell integration)Ghostty config, usually ~/.config/ghostty/config
Bring fonts, colors and terminal behavior over from iTerm2, Terminal, Alacritty, Kitty, WezTerm or a Warp themecmux import <terminal> --dry-run to preview, then cmux import <terminal>; writes cmux's own Ghostty config and a generated theme, never ~/.config/ghostty/config
Workspace names, descriptions, colors, read state, sidebar metadatacmux CLI, see ../cmux-workspace/SKILL.md
Feed event sourcescmux hooks setup

Viewer-specific JSON settings live in the global cmux.json: browser.*, markdown.*, fileEditor.*, fileExplorer.*, and diffViewer.*. Generic file preview routing also uses app.openSupportedFilesInCmux and app.openMarkdownInCmuxViewer plus app.preferredEditor. Right-sidebar tools are structural state and Dock configuration, not a templates.rightSidebarTool object.

Project-local .cmux/cmux.json and .cmux/dock.json let worktree, SSH, review, dev, CI, and docs patterns travel with the repo; project actions and commands override global entries with the same ID or name. Global app preferences do not belong there.

If a request can be handled by Ghostty config, say so and use Ghostty config instead of inventing cmux UI settings.

Key surfaces in cmux.json: actions (reusable, can appear in Cmd+Shift+P, surface tab bars, shortcuts, and the plus-button right-click menu), ui.newWorkspace.action (replaces the plus-button click) and ui.newWorkspace.contextMenu (right-click menu; ui.newWorkspace.rightClick is an accepted alias but new examples use contextMenu), ui.surfaceTabBar.buttons (replaces default tab bar buttons; include built-ins like cmux.newTerminal, cmux.newBrowser, cmux.splitRight, cmux.splitDown only when they should stay visible; copy built-ins cmux.copyWorkingDirectory, cmux.copyProjectRoot, and cmux.copyScreen also work here and in actions), and commands (workspace definitions with split layouts).

Workflow

  1. Inspect existing config.

    bash
    test -f ~/.config/cmux/cmux.json && sed -n '1,220p' ~/.config/cmux/cmux.json
    test -f .cmux/cmux.json && sed -n '1,220p' .cmux/cmux.json
  2. Pick global or project-local scope. Default to project-local for repo-specific commands, global for app preferences. Ask only when the choice changes behavior meaningfully.

  3. Back up the target file when it already exists (applicable path only, no backup for a missing file).

    bash
    stamp="$(date +%Y%m%d-%H%M%S)"
    test -f ~/.config/cmux/cmux.json && cp -p ~/.config/cmux/cmux.json ~/.config/cmux/cmux.json."$stamp".bak
    test -f .cmux/cmux.json && cp -p .cmux/cmux.json .cmux/cmux.json."$stamp".bak
  4. For app settings and cmux-owned shortcuts, use the settings helper (~/.codex/skills/... if the user installed with skills.sh).

    bash
    ~/.agents/skills/cmux-settings/scripts/cmux-settings list-supported
    ~/.agents/skills/cmux-settings/scripts/cmux-settings set browser.openTerminalLinksInCmuxBrowser true
    ~/.agents/skills/cmux-settings/scripts/cmux-settings validate
  5. For actions, UI wiring, workspace layouts, notification hooks, and Dock controls, edit the JSONC by hand and preserve unrelated sections (vault, rightSidebar, commands, actions, ui, notifications).

  6. cmux reload-config.

  7. Verify the configured entrypoint exists: read back the shortcut binding, or confirm the action ID and where it should appear.

For viewer changes, verify the exact path or command state from the matrix. If the requested viewer or knob is absent from the schema, explain that it is not supported yet instead of writing an unknown key. The templates.<viewer> surface proposed for future notes/Markdown/diff customization is not available until the schema and runtime implement it.

Example: Command Palette action

Appears in Cmd+Shift+P unless palette is false.

json
{
  "actions": {
    "codex-new-tab": {
      "type": "agent",
      "agent": "codex",
      "title": "Codex",
      "subtitle": "Start Codex in this workspace",
      "target": "newTabInCurrentPane",
      "palette": true
    }
  }
}

Before choosing a preset, template, starter config, or known workflow pattern, run cmux docs workflows --json. Its catalog describes the shipped examples, what each creates, task-fit cues, requirements, adaptation points, and the saved-layout lifecycle. After choosing an example, open references/examples.md for that example's concrete JSON recipe.

Validation

  • App settings: cmux-settings validate.
  • Keep valid JSONC, no duplicate keys.
  • Parse .cmux/dock.json or ~/.config/cmux/dock.json with a JSON parser before reporting completion.
  • cmux reload-config when the CLI is available.
  • Confirm the exact user-facing result: action title, shortcut, plus-button behavior, context-menu entry, or tab bar placement.

Rules

  • Do not overwrite a whole top-level config section unless you own the full section.
  • Do not store secrets in actions, commands, or prompts. Use environment variables or the user's secret manager.
  • Do not use sleeps or timing workarounds in generated commands.
  • Do not add a cmux setting for behavior Ghostty already owns.
  • Keep labels short enough for menus, buttons, and the Command Palette.

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Cmux Customization AI skill do?

Customize cmux for an end user, including terminal, browser, Markdown, diff, file preview, notes, HTML, and right-sidebar viewers. Use when changing cmux.json actions, custom commands, workspace layouts, plus-button behavior, surface tab bar buttons, Command Palette entries, Dock controls, sidebar and app settings, shortcuts, notifications, browser routing, examples-library presets, or Ghostty-backed terminal preferences.

Why use Cmux Customization on TypingMind?

Because you install it once and use it with any model. Cmux Customization is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Cmux Customization in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/manaflow-ai/cmux/tree/main/skills/cmux-customization. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Cmux Customization?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Cmux Customization?

As many as you like. As long as a model supports skills, you can use Cmux Customization with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Cmux Customization AI skill free?

It is published on GitHub by manaflow-ai. Check the repository for licensing terms. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇