What Programming Languages Does Kimi-Code Support?

Kimi-Code supports any programming language that the underlying LLM model has been trained on, functioning as a fully language-agnostic coding assistant without hard-coded language restrictions.

Kimi-Code, developed by MoonshotAI, takes a fundamentally different approach to language support compared to traditional IDEs or syntax-specific tools. Instead of maintaining a fixed list of supported compilers or parsers, the repository forwards your natural-language prompts directly to the configured LLM provider, enabling code generation for virtually any programming language within the model's training data.

The Language-Agnostic Architecture

System Prompt Design in AGENTS.md

The core philosophy is explicitly defined in the repository's agent configuration. According to AGENTS.md (line 9), the system instructs the model to "Write in the user's language … Keep code, commands, identifiers, file paths, and technical terms in their original form." This directive ensures that whether you request Python, Rust, or COBOL, the agent preserves your specified syntax without translation or restriction.

Model-Driven Language Capability

In packages/agent-core-v2/src/app/agent/Agent.ts, the core Agent class receives user prompts and forwards them to the underlying model. The actual language processing occurs within the LLM itself, not in Kimi-Code's codebase. This architecture means language support is determined entirely by the provider configuration defined in config.toml and handled through the provider abstraction in packages/kosong/src/provider.ts.

Practically Supported Languages

While no exhaustive list exists in the codebase, Kimi-Code effectively handles the most common modern programming languages, including:

• JavaScript and TypeScript
• Python
• Go
• Rust
• Java
• C#
• C/C++
• PHP
• Ruby

Support extends to any language the selected model can generate, including niche, domain-specific, or legacy languages, provided the LLM has relevant training data.

Configuring Providers for Language Support

Language capabilities are gated by your provider setup. The docs/en/configuration/providers.md documentation explains how each model advertises its capabilities (such as code generation for specific languages). When you configure a provider in config.toml, you select which LLM handles your requests, thereby determining which languages are effectively available. The CLI entry point in apps/kimi-code/src/cli.ts parses your --prompt flag and routes requests to the Agent, which then utilizes the configured provider's model.

Working with Different Languages

The following examples demonstrate how Kimi-Code generates language-specific code based solely on your natural-language prompts.

TypeScript Utility Generation

Request a TypeScript function using the CLI:

kimi --prompt "Create a TypeScript function called `capitalize` that takes a string and returns it with the first letter in uppercase."

The model returns properly typed TypeScript:

export function capitalize(s: string): string {
  if (!s) return '';
  return s[0].toUpperCase() + s.slice(1);
}

Python Data Processing Script

Switch languages by changing your prompt description:

kimi --prompt "Write a Python script that reads `data.csv` and prints the total of the `price` column."

Resulting Python code:

import csv

def total_price(csv_path):
    total = 0.0
    with open(csv_path, newline='') as f:
        reader = csv.DictReader(f)
        for row in reader:
            total += float(row['price'])
    return total

if __name__ == "__main__":
    print("Total price:", total_price("data.csv"))

Summary

• Kimi-Code is language-agnostic by design, with no hard-coded list of supported languages in the source code.
• Language support depends entirely on the LLM model configured in your provider settings via config.toml.
• The system prompt in AGENTS.md instructs the agent to preserve code identifiers and syntax in their original form.
• You can generate code for any programming language your chosen model supports, from mainstream languages like Python and TypeScript to niche or legacy options.
• The provider abstraction in packages/kosong/src/provider.ts manages which model capabilities are available based on your configuration.

Frequently Asked Questions

Is there a hard-coded list of supported languages in Kimi-Code?

No. Unlike traditional IDEs, Kimi-Code does not ship with a fixed enumeration of supported languages. The packages/agent-core-v2/src/app/agent/Agent.ts implementation forwards all requests to the LLM provider, making the tool capable of handling any language within the model's training data without requiring codebase modifications or language-specific plugins.

How do I switch between programming languages when using Kimi-Code?

You switch languages by modifying your natural-language prompt. Simply specify the desired language in your request (e.g., "Write a Go function..." or "Create a Ruby class..."). The CLI entry point in apps/kimi-code/src/cli.ts passes your prompt to the Agent, which maintains the language context throughout the conversation as per the AGENTS.md system instructions.

Does Kimi-Code support niche or legacy languages like Fortran or COBOL?

Yes, provided your configured LLM model was trained on those languages. Since Kimi-Code relies on the provider's model capabilities defined in packages/kosong/src/provider.ts, support for Fortran, COBOL, Assembly, or other specialized languages depends entirely on whether your selected model (configured in config.toml) can generate valid syntax for them.

Where is the language handling logic implemented in the source code?

The language-agnostic behavior is primarily enforced through the system prompt defined in AGENTS.md (root directory) and implemented in packages/agent-core-v2/src/app/agent/Agent.ts. The actual language generation occurs within the LLM itself, while packages/kosong/src/provider.ts manages which model capabilities are available based on your provider configuration.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}