Introduction

Version: 1.0.0

It reads configuration from YAML files for all of the providers you configure, it sets the required environment variables, and launches Claude Code. This means that it lets you use DeepSeek, OpenRouter, and other providers with a single flag. Optionally, there are shorthands for permissions and Remote Control sessions.

You may also view the Itch.io page for the tool, but this site has the full documentation.

Disclaimer: ccode is not affiliated with or endorsed by Anthropic. You still need a regular Claude Code install.

What does it look like?

It adds the ccode command to your shell, that lets you manage multiple profiles.

Here’s a quick example of me running with the DeepSeek profile as my default:

I can even use the --control option to enable Remote Control and see a third party provider driven session in the web or desktop apps:

Here’s that session visible in the web app (apparently experimental):

Here’s that session visible in the desktop app (did you even know they have that?):

You can even use something like OpenRouter to use models that normally don’t really talk the Anthropic API, like OpenAI models, try out how well Mistral models work with Claude Code etc.:

Note that all of the functionality above is already supported by Claude Code and is NOT something I wrote myself. Instead, I wrote the launcher to make accessing it easier, I think EVERYONE should have easy access to that.

I will still probably have an Anthropic subscription, but downgrade mine from Max to Pro. I still think that Anthropic has some of the best models for development out there, it’s just that I don’t have a lot of money. With this tool, I can easily use whatever models I prefer, many of which are more affordable (technically even local ones).

Where do you get it?

It’s offered under a pay-what-you-want model, the suggested price is 7 USD and the minimum is 0 USD.

You can get the pre-built binaries from the Itch.io page.

The tool is also offered as source-available, you can compile it yourself on your own devices.

How do you set it up?

You can use the program portably, but most folks will want to make it available in their PATH.

Commands are provided for this, to put it in the user/system directory and make it easy to invoke.

Windows:

# Install the program to use it from the terminal (restart terminal after) 
# There might be a SmartScreen warning the first time you run this executable 
# In PowerShell:
.\ccode.exe install
# Or in cmd:
ccode.exe install

Linux:

# Install the program to use it from the terminal (restart terminal after)
chmod +x ./ccode
./ccode install

Mac:

# Install the program to use it from the terminal (restart terminal after)
# To avoid Gatekeeper warnings preventing launch (until code signing is set up)
xattr -d com.apple.quarantine ./ccode
chmod +x ./ccode
./ccode install

Configuration management is the same across all platforms (the file paths differ though, of course):

# Create the config file with examples
ccode init-config
# Edit the configuration file to fill in the providers you want to use
ccode edit-config

For example, if you wanted to use DeepSeek, you’d just grab an API key at: DeepSeek Platform - API keys

They also have a Claude Code specific page with instructions, we include examples: Integrate with Claude Code

Uncomment the examples we’ve prepared and fill out your API keys, you can also change the models:

If you always want to use DeepSeek, you can also change it to be the default profile, alongside customizing any other goodies you want:

Once all of that is done, here’s the normal usage you’d use day to day:

# Launch with default profile
ccode

# Launch with a specific profile
ccode --deepseek

# Can also launch with custom permissions or Remote Control
ccode --deepseek --auto
ccode --deepseek --control

# There's also help if you need it, explaining the current config too
ccode --help
# It does override the claude default, however that help is available directly
claude --help

See the Usage page for all the details, including profile selection, permissions, and more.

You can read through the config file in more detail to see how to disable the Anthropic telemetry (this app doesn’t have any telemetry of its own btw).

See the Providers page for more setup details and some of the providers that you can use.

How does it work?

This program is a wrapper around Claude Code, that allows setting the model and API related variables to use a variety of providers, then just launches the executable.

You could get something similar with a bunch of shell scripts, but it’s easier to distribute a single binary that also lets you parse config files and work across different OSes and environments.

For more details, see the Frequently Asked Questions page.

Downloads

Current version: 1.0.0

You can also view the Changelog for version history.

Pre-built binaries

It’s offered under a pay-what-you-want model, the suggested price is 7 USD and the minimum is 0 USD.

You can get the pre-built binaries from the Itch.io page.

Source code

This program is not open source, but is made as source-available.

Here’s the instructions to compile it yourself on your own devices.

Please consult the Licenses page for more details.

Installation

Prerequisites

• Claude Code (the terminal version) must be installed and available in your PATH.

Quick install

Download and extract the archive for your platform from the Itch.io page.

You can use the program portably, but most folks will want to make it available in their PATH.

Commands are provided for this, to put it in the user/system directory and make it easy to invoke.

Windows:

# Install the program to use it from the terminal (restart terminal after) 
# There might be a SmartScreen warning the first time you run this executable 
# In PowerShell:
.\ccode.exe install
# Or in cmd:
ccode.exe install

Linux:

# Install the program to use it from the terminal (restart terminal after)
chmod +x ./ccode
./ccode install

Mac:

# Install the program to use it from the terminal (restart terminal after)
# To avoid Gatekeeper warnings preventing launch (until code signing is set up)
xattr -d com.apple.quarantine ./ccode
chmod +x ./ccode
./ccode install

On macOS, downloaded binaries are quarantined by Gatekeeper - the xattr command above removes this.

The installer will:

1. Create the install directory
2. Copy the ccode binary
3. Add the directory to your PATH

After that, you can launch it from any directory with:

ccode

It also has built in help:

# There's also help if you need it, explaining the current config too
ccode --help
# It does override the claude default, however that help is available directly
claude --help

Install locations

You can also install system-wide with ./ccode install --system (requires admin/sudo).

Depending on how you run the install command, where the app ends up will change:

After installing, restart your terminal and run the tool to create your configuration file.

Uninstalling

To remove ccode from your system:

ccode uninstall

This will check both user-level and system-level install locations for binaries, offer to clean up PATH entries, and offer to remove the configuration directory. You are prompted before each deletion - nothing is removed without your confirmation.

You can run the uninstall from the installed binary itself (it handles self-deletion).

Manual install

If you prefer to install manually, download and extract the archive, then:

Windows

mkdir "C:\Program Files\ccode"
copy ccode.exe "C:\Program Files\ccode\ccode.exe"
# Add C:\Program Files\ccode to your system PATH via:
# Settings > System > About > Advanced System Settings > Environment Variables

Linux / macOS

sudo cp ccode /usr/local/bin/ccode
sudo chmod +x /usr/local/bin/ccode

First-time setup

Here’s the setup process as an all-in-one reference with some alternative commands:

# You can install the program to use it from the terminal
# On Mac, remove the Gatekeeper quarantine attribute (until code signing is set up)
xattr -d com.apple.quarantine ./ccode
# Need to make it executable on some platforms
chmod +x ./ccode
# On Windows, there might be a SmartScreen warning the first time you run this executable
# Install for the local user
./ccode install
# Optional: Install for the system-wide user (requires sudo on some platforms)
./ccode install --system

# Create the config file with examples 
# (running ccode with no args also does the same)
ccode init-config
# You can also initialize a minimal one, without all the examples
ccode init-config --minimal

# Optional: You can also reset them to the defaults in case you want to wipe the config
ccode init-config --reset
ccode init-config --reset --minimal

# Then edit the configuration file to fill in the providers you want to use
# (you can specify whatever editor you prefer, if not using the default)
ccode edit-config
ccode edit-config vim
ccode edit-config nano
ccode edit-config zed

# Edit the config to add your API keys for whatever providers you want, setup is done

Configuration

ccode uses YAML configuration files with a two-level merge system: a user-level config for secrets and an optional project-level config for model settings.

Config locations

Field naming

Every profile field maps 1:1 to a Claude Code environment variable. The YAML field name is the lowercased env var name:

ANTHROPIC_BASE_URL        ->  anthropic_base_url
ANTHROPIC_MODEL           ->  anthropic_model
CLAUDE_CODE_EFFORT_LEVEL  ->  claude_code_effort_level

For the full list of ~200+ supported fields, see the Config Reference.

Merge behavior

When both user and project configs exist, ccode merges them field-by-field:

1. User config is loaded first (base layer, carries secrets)
2. Project config is overlaid on top (model settings override user values)
3. --config flag replaces the project config in the merge chain

Launch modes

ccode can automatically enable Claude Code’s launch modes via config. Each has a --flag/--no-flag CLI override.

always_yolo takes priority over always_auto (they’re mutually exclusive permission modes). always_control can be combined with either.

Note: At the time of writing, claude remote-control does not accept custom permission flags (--dangerously-skip-permissions or --permission-mode auto). Combining --control with --auto or --yolo will print a warning but still attempt to pass the flags, in case a future Claude Code update enables it. Auto permissions can be set in the Claude app/web UI instead.

Global env

The top-level env: block sets environment variables for all profiles. This is useful for settings you want everywhere:

env:
  DISABLE_TELEMETRY: "1"
  CLAUDE_AUTOCOMPACT_PCT_OVERRIDE: "80"

profiles:
  default: {}
  deepseek:
    anthropic_base_url: https://api.deepseek.com/anthropic
    anthropic_auth_token: sk-your-key-here

Each profile can also have its own env: block for per-profile overrides. Priority order: global env < profile fields < profile env.

Example user config

default_profile: deepseek

profiles:
  # Passthrough - launches Claude Code as-is with your subscription
  default: {}

  deepseek:
    anthropic_base_url: https://api.deepseek.com/anthropic
    anthropic_auth_token: sk-your-deepseek-key-here
    anthropic_model: "deepseek-v4-pro[1m]"
    anthropic_default_opus_model: "deepseek-v4-pro[1m]"
    anthropic_default_sonnet_model: "deepseek-v4-pro[1m]"
    anthropic_default_haiku_model: deepseek-v4-flash
    claude_code_subagent_model: deepseek-v4-flash
    claude_code_effort_level: max
    env:
      CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS: "1"

Split config example

User config (~/.config/ccode/config.yaml) - has secrets, never committed:

default_profile: deepseek
profiles:
  deepseek:
    anthropic_auth_token: sk-abc123
  openrouter:
    anthropic_auth_token: sk-or-xyz789

Project config (./ccode.yaml) - safe to commit:

default_profile: deepseek
profiles:
  deepseek:
    anthropic_base_url: https://api.deepseek.com/anthropic
    anthropic_model: "deepseek-v4-pro[1m]"
    anthropic_default_opus_model: "deepseek-v4-pro[1m]"
    anthropic_default_sonnet_model: "deepseek-v4-pro[1m]"
    anthropic_default_haiku_model: deepseek-v4-flash
    claude_code_subagent_model: deepseek-v4-flash
    claude_code_effort_level: max
    env:
      CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS: "1"

The merged result has both the API key (from user config) and the model settings (from project config).

The idea is that the project configs could allow using a faster model (like DeepSeek V4 Flash) for one project, and demand using a bigger model (like DeepSeek V4 Pro) for another, all while the actual API keys per-user remain private and there’s lower risk of accidentally committing and pushing them somewhere public.

If you need per-project API keys or want them committed to your private repositories you can do that too, just please be careful.

More info

• Providers - setup guides for every supported provider
• Config Reference - complete list of all YAML fields

Providers

ccode supports a variety of model providers out of the box. Each provider gets its own profile in your config file. This page covers the setup for each supported provider type.

For the full list of available YAML fields, see the Config Reference.

Anthropic direct

The simplest setup. ccode launches Claude Code without setting any environment variables.

Subscription passthrough

If you have a Claude Pro, Max, Team, or Enterprise subscription, the default: {} profile launches Claude Code as-is:

profiles:
  default: {}

API key billing

For pay-per-token billing through Anthropic’s API, set anthropic_api_key:

profiles:
  anthropic:
    anthropic_api_key: sk-ant-your-key-here

Get your API key at console.anthropic.com.

First-party cloud providers

These run Claude models on AWS, GCP, or Azure infrastructure. Authentication uses your cloud provider’s credentials, not an Anthropic auth token.

Amazon Bedrock

profiles:
  bedrock:
    claude_code_use_bedrock: true

AWS credentials are handled by IAM (roles, SSO, environment variables, credential files). See Anthropic’s Bedrock docs.

Optional settings: anthropic_bedrock_base_url, claude_code_skip_bedrock_auth, aws_bearer_token_bedrock, anthropic_bedrock_service_tier.

Amazon Bedrock Mantle

profiles:
  mantle:
    claude_code_use_mantle: true

A variant of Bedrock with a dedicated endpoint. See Anthropic’s Mantle docs.

Google Vertex AI

profiles:
  vertex:
    claude_code_use_vertex: true
    anthropic_vertex_project_id: your-gcp-project-id

Uses Google Cloud application default credentials (gcloud auth). See Anthropic’s Vertex AI docs.

Microsoft Foundry (Azure)

profiles:
  foundry:
    claude_code_use_foundry: true
    anthropic_foundry_base_url: https://your-resource.services.ai.azure.com/anthropic
    anthropic_foundry_api_key: YOUR_FOUNDRY_API_KEY_HERE

See Anthropic’s Foundry docs.

Third-party providers (native Anthropic format)

These providers expose an Anthropic-compatible API endpoint. Each needs anthropic_base_url and anthropic_auth_token.

Tip: Most third-party providers need CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS set to "1" in their env: block. This strips Anthropic-specific headers that non-Anthropic providers reject.

DeepSeek

Sign up at platform.deepseek.com.

profiles:
  deepseek:
    anthropic_base_url: https://api.deepseek.com/anthropic
    anthropic_auth_token: YOUR_DEEPSEEK_API_KEY_HERE
    anthropic_model: "deepseek-v4-pro[1m]"
    anthropic_default_opus_model: "deepseek-v4-pro[1m]"
    anthropic_default_sonnet_model: "deepseek-v4-pro[1m]"
    anthropic_default_haiku_model: deepseek-v4-flash
    claude_code_subagent_model: deepseek-v4-flash
    claude_code_effort_level: max
    env:
      CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS: "1"

OpenRouter

Sign up at openrouter.ai. OpenRouter gives access to 400+ models behind a single endpoint.

profiles:
  openrouter:
    anthropic_base_url: https://openrouter.ai/api
    anthropic_auth_token: YOUR_OPENROUTER_API_KEY_HERE
    anthropic_model: anthropic/claude-sonnet-4.6
    anthropic_default_opus_model: anthropic/claude-opus-4.7
    anthropic_default_sonnet_model: anthropic/claude-sonnet-4.6
    anthropic_default_haiku_model: anthropic/claude-haiku-4.5
    claude_code_subagent_model: anthropic/claude-haiku-4.5
    env:
      CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS: "1"

OpenRouter presets: You can create presets at openrouter.ai/workspaces/default/presets and use them as model names with the @preset/slug syntax.

Z.AI (Zhipu GLM)

Sign up at z.ai (international) or open.bigmodel.cn (China).

profiles:
  zai:
    anthropic_base_url: https://api.z.ai/api/anthropic
    anthropic_auth_token: YOUR_ZAI_API_KEY_HERE
    anthropic_model: glm-5.1
    anthropic_default_opus_model: glm-5.1
    anthropic_default_sonnet_model: glm-5.1
    anthropic_default_haiku_model: glm-4.5-air
    claude_code_subagent_model: glm-4.5-air
    env:
      CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS: "1"

Moonshot Kimi

Sign up at kimi.ai.

profiles:
  kimi:
    anthropic_base_url: https://api.moonshot.ai/anthropic
    anthropic_auth_token: YOUR_KIMI_API_KEY_HERE
    anthropic_model: kimi-k2.6
    env:
      CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS: "1"

Alibaba Qwen (DashScope)

Sign up at alibabacloud.com.

profiles:
  qwen:
    anthropic_base_url: https://dashscope-intl.aliyuncs.com/apps/anthropic
    anthropic_auth_token: YOUR_DASHSCOPE_API_KEY_HERE
    anthropic_model: qwen3.6-plus
    env:
      CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS: "1"

MiniMax

Sign up at minimax.io.

profiles:
  minimax:
    anthropic_base_url: https://api.minimax.io/anthropic
    anthropic_auth_token: YOUR_MINIMAX_API_KEY_HERE
    anthropic_model: MiniMax-M2.7
    env:
      CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS: "1"

Local and self-hosted models

Point anthropic_base_url at your local server. Several tools support the Anthropic Messages API format natively:

• llama.cpp - native /v1/messages support (github.com/ggml-org/llama.cpp)
• vLLM - native /v1/messages since v0.4 (github.com/vllm-project/vllm)
• Ollama - Anthropic-compatible endpoint (ollama.com)
• LM Studio - Anthropic-compatible endpoint (lmstudio.ai)

profiles:
  local:
    anthropic_base_url: http://localhost:8080/v1
    anthropic_auth_token: not-needed
    anthropic_model: your-local-model
    env:
      CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS: "1"
      DISABLE_INTERLEAVED_THINKING: "1"
      CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK: "1"

For tools that only speak OpenAI format, use a translation proxy:

• LiteLLM - github.com/BerriAI/litellm

Common gotchas

Community resources

For an actively maintained reference of model IDs, pricing, and per-provider configs, see the Alorse/cc-compatible-models repo on GitHub.

Usage

Basic usage

# Launch with default profile
ccode

# Launch with a specific profile
ccode --bedrock
ccode --deepseek
ccode --openrouter
ccode --openrouter-preset
ccode --zai
ccode --kimi
ccode --qwen
ccode --minimax
ccode --some-other-custom-profile

# There's also a longer form for profiles
# (in case they'd add a --bedrock flag and you couldn't use such a shorthand)
ccode --profile bedrock

# Pass arguments through to Claude Code
ccode --deepseek --ide
ccode --deepseek -p "Fix the bug in auth.py"

Profile selection

Profiles are selected in this priority order:

1. --profile <name> flag (explicit, always works)
2. --<name> shortcut (auto-generated from profile names)
3. default_profile from config

Profile shortcuts

Every profile name automatically becomes a --<name> shortcut. If you have a profile called deepseek, then --deepseek works.

If a profile name collides with a Claude Code flag (e.g. you named a profile model), the shortcut is disabled and ccode will warn you. Use --profile model instead.

Commands

ccode install

Installs the ccode binary to your PATH. See the Installation page for full details.

ccode install            # User-level install (no admin/sudo required)
ccode install --system   # System-wide install (requires admin/sudo)

ccode init-config

Creates the default user configuration file and prints its path.

ccode init-config                        # Create config (fails if exists)
ccode init-config --minimal              # Create minimal config (Anthropic only)
ccode init-config --reset                # Overwrite existing config with defaults
ccode init-config --minimal --reset      # Reset with minimal config
ccode init-config ccode.yaml             # Create config at a custom path
ccode init-config --minimal ccode.yaml   # Create minimal config at custom path

The --minimal flag creates a smaller configuration with only the top-level settings and Anthropic direct profiles (no cloud providers, third-party providers, or local model examples). Useful for quick setup or project-level configs.

ccode edit-config

Opens the user config file in a text editor. If no config exists, it creates one first.

ccode edit-config            # Open in default editor
ccode edit-config vim        # Open in a specific editor

The editor is resolved in this order: command argument > $EDITOR > $VISUAL > platform default (notepad on Windows, nano on Linux/macOS).

ccode profiles

Lists all available profiles from the merged configuration.

$ ccode profiles
User config:     C:\Users\you\AppData\Roaming\ccode\config.yaml
Default profile: default
Always control:  false  (shortcuts: --control or --no-control)
Always auto:     false  (shortcuts: --auto or --no-auto)
Always yolo:     false  (shortcuts: --yolo or --no-yolo)

Available profiles:
  > default
      type:     subscription passthrough
      shortcut: --default
    deepseek
      type:     https://api.deepseek.com/anthropic (deepseek-v4-pro[1m])
      shortcut: --deepseek
    openrouter
      type:     https://openrouter.ai/api (anthropic/claude-sonnet-4.6) [no auth]
      shortcut: --openrouter

ccode --help

Shows ccode’s own help, including the current config paths, available profiles, and ccode-specific commands and flags.

ccode --help

Since ccode wraps Claude Code, it overrides the default claude --help. The original Claude Code help is always available directly:

claude --help

ccode uninstall

Removes ccode binaries, PATH entries, and optionally the configuration directory. You are prompted before each deletion - nothing is removed without your confirmation. See the Installation page for full details.

ccode uninstall

Launch modes

ccode can automatically enable Claude Code’s launch modes. Set always_control, always_auto, or always_yolo in your config, or use CLI flags to override per-launch:

# Remote control - sessions show up at claude.ai/code
ccode --control                # Enable for this session
ccode --no-control             # Disable for this session

# Auto permissions - Claude handles permission prompts automatically
ccode --auto                   # Enable for this session
ccode --no-auto                # Disable for this session

# Skip permissions - bypass all permission prompts (be careful!)
ccode --yolo                   # Enable for this session
ccode --no-yolo                # Disable for this session

# Combine modes
ccode --control --yolo         # Remote control + skip permissions

# Combine with profiles
ccode --deepseek --auto
ccode --deepseek --yolo
ccode --deepseek --control

--yolo takes priority over --auto (they’re mutually exclusive permission modes). --control can be combined with either.

Note: At the time of writing, claude remote-control does not accept custom permission flags (--dangerously-skip-permissions or --permission-mode auto). Combining --control with --auto or --yolo will print a warning but still attempt to pass the flags, in case a future Claude Code update enables it. Auto permissions can be set in the Claude app/web UI instead.

Passthrough

We have a few commands/flags of our own, but all other flags are passed through to Claude Code. We try not to have naming conflicts.

All Claude Code flags and arguments work as expected:

ccode --deepseek --continue          # Resume last conversation
ccode --deepseek -r                  # Interactive session picker
ccode --deepseek --worktree          # New git worktree
ccode --deepseek --debug             # Debug mode

Use -- to force everything after it to be passed through:

ccode --deepseek -- --some-future-flag

FAQ

General

What is ccode?

ccode is a third-party launcher for Claude Code that adds profile management. It lets you switch between different model providers (Anthropic, DeepSeek, OpenRouter, Bedrock, etc.) with a single flag.

Is ccode affiliated with Anthropic?

No. ccode is not affiliated with or endorsed by Anthropic. It’s an independent, source-available tool.

Why not just use OpenCode (or similar)?

Other harnesses like OpenCode are lovely, but some people are more familiar with Claude Code, and it also has good support for various models on a per-task basis (e.g. sub-agents), permission controls etc.

You can even do something like launch it with ccode --deepseek remote-control and view the session either in your browser or the Claude Desktop app on any of your devices, even if the underlying model is different!

So with this tool you get both the Claude Code user experience that you enjoy, as well as pricing from other providers that you may enjoy more. See also Similar Software for alternatives.

Does ccode collect any data?

No. There’s no analytics or telemetry in ccode itself. Your prompts, API keys, and usage data stay between you and your chosen model provider.

Does ccode modify Claude Code?

No. ccode is a launcher, not a patch. It sets environment variables and then runs the standard claude binary. Claude Code itself is unchanged.

Configuration

Where is my config file?

Run ccode profiles to see the exact path, or ccode edit-config to open it directly.

What’s the difference between the full and minimal config?

The full config (ccode init-config) includes commented-out examples for every supported provider: cloud providers (Bedrock, Vertex, Foundry), third-party providers (DeepSeek, OpenRouter, Z.AI, Kimi, Qwen, MiniMax), and local models. It’s 350+ lines.

The minimal config (ccode init-config --minimal) includes only the top-level settings and Anthropic direct profiles. It’s about 100 lines, and is useful for quick setup or project-level configs.

Can I use a project-level config?

Yes. Place a ccode.yaml (or .claude/ccode.yaml) in your project root. It merges with your user config at the field level, so you can put model settings in the project config and keep API keys in your user config. See Configuration for details.

How do I add a provider that isn’t in the default config?

Any provider that exposes an Anthropic-compatible API endpoint (/v1/messages) works. Set anthropic_base_url to the provider’s endpoint and anthropic_auth_token to your API key. See Providers for examples.

Profiles

How do profile shortcuts work?

Every profile name automatically becomes a --<name> CLI shortcut. If you have a profile called deepseek, then ccode --deepseek is equivalent to ccode --profile deepseek.

If a profile name collides with a Claude Code flag (e.g. you named a profile model), the shortcut is disabled and you’ll need to use --profile model instead.

Can I use multiple profiles at once?

No. Only one profile is active per session. However, you can set a different default_profile in a project-level config, so different projects can use different providers automatically.

How do I set a default profile?

Set default_profile in your config:

default_profile: deepseek

This profile is used when you run ccode without specifying one.

Troubleshooting

“No configuration found” on first run

This is normal. ccode creates a default config automatically on first run and tells you where it is. Edit the file to add your API keys, then run ccode again.

My profile shows “[no auth]”

This means the profile is missing authentication credentials. For third-party providers, you need anthropic_auth_token. For Anthropic API, you need anthropic_api_key. Run ccode profiles to see which profiles have this warning.

Claude Code flags aren’t working

Make sure you’re putting ccode flags before Claude Code flags:

# Correct
ccode --deepseek --continue

# Also correct (-- forces everything after it to pass through)
ccode --deepseek -- --some-flag

All flags that aren’t recognized by ccode are passed through to Claude Code automatically.

Licensing and pricing

Why source available license, not open source? Why not develop on GitHub?

A source available license was picked, so people wouldn’t just resell this app or sidestep the distribution method.

The limitation on no distribution of binaries is there so people also can’t just put something in the app that might be malicious or problematic, like telemetry. You are allowed to make forks and even make them available to others, but it must be a source distribution - so people can inspect the code and compile it themselves.

The source is not on GitHub, because I’m not really interested in the social aspects of development and providing free support. You can e-mail me, just don’t be mean.

Why charge money for this at all? Why allow 0 USD prices (free downloads)? Why Itch.io?

Someone has to pay for the Apple Developer account license, so I can sign the software and not have to ask people to work around quarantine restrictions.

At the same time, if someone doesn’t want to pay, they can still download the program for free, since that’s probably a bit safer than something like torrenting. Treat it like a WinRAR trial if you please.

I also chose Itch.io for the pay-what-you-want features, so it meets people’s needs better, given how many with different circumstances there are. If this shows that people will just download it for free and not pay, then so be it.

Frankly I’m helping a friend with their medical expenses, so I don’t really get to bad about trying to earn a buck in addition to my job with this.

What about updates? Do I have to pay if I only want the source?

I mostly ask for money for the prebuilt binaries and even that is optional.

If you feel like throwing a few dollars my way for the source, then that’s nice, if not, then that’s okay.

If updates come out and you’ve bought an older version, I don’t see an issue of you downloading the new version for free.

Can’t this be replicated in an evening?

Sure, probably in a few days. I just made something that I wanted to use. No reason why I couldn’t make it more widely available.

There was some annoying stuff around changing env variables and just multi-OS support in general, and OpenRouter seems to not work too well with claude -p and needs workarounds.

Development questions

I found a bug, how do I report it?

You can just send me an e-mail, the details are on my homepage.

Alternatively, Itch.io should also let you leave comments, probably easier.

Past that, I can’t commit to an SLA, since my job takes up most of my time.

Is there a roadmap?

Not quite, I’ll add whatever features seem nice.

I’m currently thinking about commands to add configuration interactively like:

• ccode add-profile
• and ccode remove-profile my-custom-profile.

I’m also considering that it’d be nice to be able to add profiles from URLs where they are hosted:

• ccode add-profile --from-url https://my-company.com/ccode/deepseek.yml

or thereabout.

Maybe it’d be nice to include an optional Anthropic API –> OpenAI API proxy to run locally, to support additional providers, but that might bloat the binary a little bit.

I’ve done something similar already internally for a company project, but I don’t want to bloat this app too much.

Will other harnesses like OpenCode be supported?

I was thinking about this, but that’d kind of bloat the config - and there’d probably be some confusion over that, managing just Claude Code is simpler.

OpenCode already has some settings files and while they’re not too comfy to manage, they seem to work already. I’ll just develop this well first.

How much of this is vibe coded?

A bunch. Then again, I’m not handling high volume financial transactions with that code, I’m just writing a convenience tool, so there’s not a lot of reason not to.

What is the site running on?

It’s a tool called mdBook, I really like it!

You input Markdown, it gives you a static HTML site that you can host wherever (I personally still like the Apache2 web server in a Docker container).

Changelog

1.0.0

First stable release.

• Launcher that sets environment variables per profile and runs the official claude binary
• All 235 official Claude Code environment variables supported as first-class YAML fields, plus an env: escape hatch for anything unmapped
• Named profiles with automatic --<profile> shortcuts, collision-checked against Claude Code flags
• Two-level config merge: user-level config (carries secrets) and optional project-level config (./ccode.yaml or ./.claude/ccode.yaml) merged at the field level
• --config <path> flag to swap in an explicit project-level config
• Global env: block applied to all profiles; per-profile env: blocks take priority
• Subscription passthrough via the empty default: {} profile (launches Claude Code as-is with your existing subscription)
• Auth validation per profile with [no auth] warning in ccode profiles
• Built-in profile examples for Anthropic (direct + API), Amazon Bedrock, Bedrock Mantle, Google Vertex AI, Microsoft Foundry, DeepSeek, OpenRouter (with preset support), Z.AI, Moonshot Kimi, Alibaba Qwen, and MiniMax
• Local model support (llama.cpp, vLLM, Ollama, LM Studio) via anthropic_base_url
• Launch modes: always_control / always_auto / always_yolo config flags with matching --control / --auto / --yolo CLI overrides (and --no-* counterparts)
• Warning when combining --control with --auto or --yolo, since Claude Code’s remote-control ignores permission flags at the time of writing
• ccode init-config with --reset, --minimal, and custom output path
• ccode edit-config opens the config in your preferred editor (command arg > $EDITOR > $VISUAL > platform default)
• ccode install for user-level install, --system for system-wide; PATH updated via Windows registry + WM_SETTINGCHANGE broadcast, or shell rc files on Unix (bash, zsh, fish, .profile)
• ccode profiles lists available profiles, default, launch modes, shortcuts, and auth status
• Argument passthrough for unknown flags, with -- as the explicit passthrough sentinel
• Subcommand typo hints (ccode init -> init-config, ccode --install -> install, etc.)
• Cross-platform builds for Windows, Linux, and macOS (amd64 + arm64)
• Pre-build drift detection against upstream Claude Code docs (env vars, CLI flags, config reference)
• Em-dash and en-dash replacement script for consistent formatting
• mdBook documentation site at ccode.kronis.dev

Licenses

This page lists the license for ccode itself, followed by the licenses of its dependencies.

ccode

Here’s the license for ccode:

END-USER LICENSE AGREEMENT FOR CCODE

IMPORTANT: PLEASE READ THE TERMS AND CONDITIONS OF THIS LICENSE AGREEMENT CAREFULLY BEFORE CONTINUING WITH THIS PROGRAM INSTALLATION OR USAGE.

This End-User License Agreement ("EULA") is a legal agreement between you (either an individual or a single entity) and Kristians Kronis (hereinafter referred to as "Licensor"),
for the software product(s) identified above which may include associated software components, media, printed materials, and "online" or electronic documentation ("SOFTWARE PRODUCT").
By installing, copying, or otherwise using the SOFTWARE PRODUCT, you agree to be bound by the terms of this EULA.
This license agreement represents the entire agreement concerning the program between You and the Licensor, and it supersedes any prior proposal, representation, or understanding between the parties.
If you do not agree to the terms of this EULA, do not install or use the SOFTWARE PRODUCT.

The SOFTWARE PRODUCT is protected by copyright laws and international copyright treaties, as well as other intellectual property laws and treaties. The SOFTWARE PRODUCT is licensed, not sold.

1. GRANT OF LICENSE.
The SOFTWARE PRODUCT is licensed as follows:
(a) Installation and Use.
The Licensor grants you the right to install and use copies of the SOFTWARE PRODUCT on your computer running a validly licensed copy of the operating system for which the SOFTWARE PRODUCT was designed.
(b) Backup Copies.
You may also make copies of the SOFTWARE PRODUCT as may be necessary for backup and archival purposes.

2. DESCRIPTION OF OTHER RIGHTS AND LIMITATIONS.
(a) Maintenance of Copyright Notices.
You must not remove or alter any copyright notices on any and all copies of the SOFTWARE PRODUCT.
(b) Distribution.
You may not distribute copies of the SOFTWARE PRODUCT to third parties.
(c) Rental.
You may not rent, lease, or lend the SOFTWARE PRODUCT.
(d) Compliance with Applicable Laws.
You must comply with all applicable laws regarding use of the SOFTWARE PRODUCT.
(e) Source code.
You may compile and modify the source code of the SOFTWARE PRODUCT for your own personal purposes, to propose contributions to the SOFTWARE PRODUCT.
You may maintain a publicly available source-only fork, provided that the source code is made available free of charge, in compliance with this EULA and without additional limitations.
You may not distribute the SOFTWARE PRODUCT or any derivative work thereof in compiled or binary form to third parties.

3. TERMINATION
Without prejudice to any other rights, the Licensor may terminate this EULA if you fail to comply with the terms and conditions of this EULA. In such event, you must destroy all copies of the SOFTWARE PRODUCT in your possession.

4. COPYRIGHT
All title, including but not limited to copyrights, in and to the SOFTWARE PRODUCT and any copies thereof are owned by the Licensor or its suppliers.
All title and intellectual property rights in and to the content which may be accessed through use of the SOFTWARE PRODUCT is the property of the respective content owner
and may be protected by applicable copyright or other intellectual property laws and treaties. This EULA grants you no rights to use such content.
All rights not expressly granted are reserved by the Licensor.

5. NO WARRANTIES
The Licensor expressly disclaims any warranty for the SOFTWARE PRODUCT.
The SOFTWARE PRODUCT is provided 'As Is' without any express or implied warranty of any kind, including but not limited to any warranties of merchantability, noninfringement, or fitness of a particular purpose.
The Licensor does not warrant or assume responsibility for the accuracy or completeness of any information, text, graphics, links or other items contained within the SOFTWARE PRODUCT.
The Licensor makes no warranties respecting any harm that may be caused by the transmission of a computer virus, worm, time bomb, logic bomb, or other such computer program.
The Licensor further expressly disclaims any warranty or representation to any user or to any third party.

6. LIMITATION OF LIABILITY
In no event shall the Licensor be liable for any damages (including, without limitation, lost profits, business interruption, or lost information) rising out of any use of or inability to use the SOFTWARE PRODUCT,
even if the Licensor has been advised of the possibility of such damages. In no event will the Licensor be liable for loss of data or for indirect, special, incidental, consequential (including lost profit),
or other damages based in contract, tort or otherwise. The Licensor shall have no liability with respect to the content of the SOFTWARE PRODUCT or any part thereof, including but not limited to errors
or omissions contained therein, libel, infringements of rights of publicity, privacy, trademark rights, business interruption, personal injury, loss of privacy, moral rights or the disclosure of confidential information.

gopkg.in/yaml.v3

Used for YAML configuration file parsing.

This project is covered by two different licenses: MIT and Apache.

#### MIT License ####

The following files were ported to Go from C files of libyaml, and thus
are still covered by their original MIT license, with the additional
copyright staring in 2011 when the project was ported over:

    apic.go emitterc.go parserc.go readerc.go scannerc.go
    writerc.go yamlh.go yamlprivateh.go

Copyright (c) 2006-2010 Kirill Simonov
Copyright (c) 2006-2011 Kirill Simonov

Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

### Apache License ###

All the remaining project files are covered by the Apache license:

Copyright (c) 2011-2019 Canonical Ltd

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

golang.org/x/sys

Used for platform-specific system calls (PATH modification on Windows and Unix).

Copyright 2009 The Go Authors.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:

   * Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
   * Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following disclaimer
in the documentation and/or other materials provided with the
distribution.
   * Neither the name of Google LLC nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Config Reference

Every profile field maps 1:1 to a Claude Code environment variable. The YAML field name is the lowercased env var name.

For the full official documentation, see code.claude.com/docs/en/env-vars.

How fields work

• String fields are set as-is when non-empty.
• Bool fields emit "1" when true, and are skipped when false.
• The env: map is an escape hatch for any env var not covered by a named field.

Priority order

When a profile is launched, environment variables are applied in this order (later wins):

1. Global env: block (top-level, applies to all profiles)
2. Profile struct fields (the named YAML fields below)
3. Profile env: block (per-profile escape hatch)

Authentication & Routing

Model Selection

Model Display Overrides

First-Party Cloud Providers

Context, Thinking, Retries

Streaming, Timeouts, Networking

MCP & Tools

Caching

Plugins, Hooks, Skills, Agents

Telemetry & Observability

Privacy, Kill-switches, Behavior Toggles

UI & Display

System

IDE

Remote Control

Vertex Regions

Auto-set at Runtime

These are set automatically by Claude Code. Including them in your config is harmless but pointless.

Deprecated

Escape hatch: env

The env: map lets you set arbitrary environment variables that don’t have a named field:

profiles:
  my-profile:
    anthropic_base_url: https://example.com
    env:
      # Standard OTel variables, custom provider settings, etc.
      OTEL_SERVICE_NAME: "my-claude-code"
      MY_CUSTOM_VAR: "value"

Global env: at the top level applies to all profiles:

env:
  DISABLE_TELEMETRY: "1"

profiles:
  default: {}
  deepseek:
    anthropic_base_url: https://api.deepseek.com/anthropic

Source & Compilation

You can grab the source as a ZIP from the Downloads page.

Tested on Go 1.25, should work on newer versions too.

# Build for current platform
cd folder-with-source-code
go build -o ccode .

You can then run ./ccode install to install the freshly built binary.

Similar software

Here’s some other software packages that are similar to ccode and might be of interest to you.

• claudectx by FGRibreau
• claude-code-profiles by quinnjr
• ai-claude-start by op7418
• claude-code-launcher by tkpdx01

This isn’t an endorsement of any of them, I just looked around a bit. If ccode isn’t sufficient for your needs, feel free to have a look at those (and possibly any other alternatives).