Tools

cc-switch: One GUI to Rule Multiple AI Coding CLIs

A Rust desktop app with 128k stars that centralizes Provider, API Key, and Base URL settings for Claude Code, Codex, and other AI CLIs — with one-click switching that doesn't restart the CLI process.

Font size

Running Claude Code in one terminal window and Codex in another has become routine for many AI developers this year. Two CLIs, two config directories, two sets of API keys. Switching providers means manually editing files or restarting the session. cc-switch has a simple pitch: put all of that in one GUI window and switch with a click.

It's sitting at 128k stars on GitHub, near the top of the AI developer tools category.

The problem it solves

When you run Claude Code, Codex, OpenCode, and similar CLIs at the same time, their configs are scattered across ~/.claude/, ~/.codex/, and other directories. API keys are managed separately, and switching providers requires manually editing files or restarting the session.

cc-switch consolidates all of that into a single GUI window.

This is especially relevant for developers working with overseas services like Claude and GPT that require proxy endpoints. Juggling several proxies, official accounts, and different subscription tier keys means manually editing ANTHROPIC_BASE_URL in settings.json every time you switch. After a month of that, the fatigue sets in.

How to use it

Download the installer from the official site — macOS, Windows, and Linux are all covered (note: the draft link https://ccswitch.io wasn't confirmed in source materials, verify before publishing).

After launching, the left sidebar lists supported CLIs (check the repo README for the current list):

  • Claude Code
  • Codex
  • OpenCode
  • Others (actively being added)

Click into Claude Code and you'll see the currently active Provider, API Key, and Base URL. Hit "Add Provider," fill in the name, key, and base URL, then save. Next time the Claude Code CLI launches, it picks up the new config — no need to touch ~/.claude/settings.json.

The entire workflow is GUI-based. No code required.

How it works (educated guess)

Rust desktop app, and judging by the installer size (around 200MB), it's almost certainly Tauri (WebView frontend + Rust backend) rather than Electron — Electron packages typically start at 400MB+. The architecture below is inferred from similar tools; check the source for the actual implementation.

Core design points:

  1. Adapter abstraction layer: Each CLI tool gets its own adapter that handles reading and writing its config directory. A ClaudeAdapter knows the shape of ~/.claude/settings.json; a CodexAdapter knows the schema of ~/.codex/config.toml.
  2. Provider model: A user-created "Provider" is essentially a config template — Key + Base URL + model name. Switching = rendering that template into the target CLI's config file format.
  3. Hot switching: After a config change, the running CLI process gets a signal to reload. Common approaches include SIGUSR1 or inotify-based file watching.

Pseudocode example (inferred):

// Pseudocode: core flow for switching providers
fn switch_provider(cli: CliType, provider: Provider) -> Result<()> {
    // 1. Back up the current config
    let config_path = cli.config_path(); // e.g. ~/.claude/settings.json
    backup(config_path)?;

    // 2. Render the Provider template into the target CLI's config
    let adapter = cli.adapter(); // ClaudeAdapter / CodexAdapter / ...
    let target_config = adapter.render(provider)?;
    fs::write(config_path, target_config)?;

    // 3. Signal the running CLI process to reload
    notify_process(cli.process_name(), Signal::Reload)?;

    Ok(())
}

One adapter per CLI, with all those different config schemas abstracted into a unified Provider object — that's the key to fitting multiple CLIs into the same GUI.

Strengths and weaknesses

Where it works well:

  • Cross-platform coverage: macOS, Windows, and Linux
  • Written in Rust, so startup is fast and memory usage is low
  • Low barrier to entry — anyone who can point and click can use it
  • Supports multiple major AI CLIs, with new ones being added
  • Actively maintained at farion1231/cc-switch

Where it falls short:

  • For users who live in dotfiles and shell aliases, a GUI feels like overkill
  • When a CLI's config schema changes, the adapter needs to be updated — rapid CLI upgrades can cause breakage
  • Closed-source desktop binary — you can't audit the code, so security comes down to trusting the author

Compared to alternatives:

vs. aider's --model flag: straightforward model switching on the command line, but it only handles model names, not Key or Base URL switching.

vs. your own shell function for swapping env vars: flexible and self-maintained, fine for a single CLI, but gets messy across multiple CLIs and multiple keys.

cc-switch positions itself as "centralized management for multiple keys, accounts, and CLIs." Heavier than a command-line solution, but considerably less hassle than maintaining a pile of dotfiles by hand.

Who should use it

Good fit for:

  • Developers running 2+ AI CLIs simultaneously
  • Anyone juggling multiple API keys or proxy endpoints
  • People tired of hand-editing settings.json
  • Teams where some members prefer GUI over command line

Not a good fit for:

  • Users who stick to just one CLI like Claude Code
  • Command-line purists who are happy with shell aliases
  • Anyone uncomfortable with closed-source binaries (you could wait for a fully open-source alternative from the community)
  • People with a single key to switch — that's overkill

Some thoughts

Tools like cc-switch exist because AI coding tools are still in a "config hell" phase. Each CLI has its own config system, schemas differ, and switching is clunky. Once you hit five or six tools, config management becomes its own problem.

In the short term, "config aggregators" like this have a market. In the long term, one of two things will likely happen: either the CLI tools themselves standardize on a common config format (something like a unified spec under ~/.config/ai/), or IDEs and editors absorb the config layer entirely (think Cursor, Windsurf). Either way, middleman tools like cc-switch get squeezed out over time.

But that's a future concern. Right now — if you're running both Claude Code and Codex, give it a try. The repo is at farion1231/cc-switch. Skim the README before downloading.

Source: https://github.com/farion1231/cc-switch