# What Programming Languages Does Kimi-Code Support?

> Discover the extensive programming languages supported by Kimi-Code. This language-agnostic assistant works with any LLM trained language, offering unparalleled versatility. Learn more today.

- Repository: [Moonshot AI/kimi-code](https://github.com/MoonshotAI/kimi-code)
- Tags: getting-started
- Published: 2026-07-24

---

**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`](https://github.com/MoonshotAI/kimi-code/blob/main/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`](https://github.com/MoonshotAI/kimi-code/blob/main/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`](https://github.com/MoonshotAI/kimi-code/blob/main/config.toml) and handled through the provider abstraction in [`packages/kosong/src/provider.ts`](https://github.com/MoonshotAI/kimi-code/blob/main/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`](https://github.com/MoonshotAI/kimi-code/blob/main/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`](https://github.com/MoonshotAI/kimi-code/blob/main/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`](https://github.com/MoonshotAI/kimi-code/blob/main/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:

```bash
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:

```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:

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

```

Resulting Python code:

```python
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`](https://github.com/MoonshotAI/kimi-code/blob/main/config.toml).
- The system prompt in [`AGENTS.md`](https://github.com/MoonshotAI/kimi-code/blob/main/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`](https://github.com/MoonshotAI/kimi-code/blob/main/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`](https://github.com/MoonshotAI/kimi-code/blob/main/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`](https://github.com/MoonshotAI/kimi-code/blob/main/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`](https://github.com/MoonshotAI/kimi-code/blob/main/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`](https://github.com/MoonshotAI/kimi-code/blob/main/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`](https://github.com/MoonshotAI/kimi-code/blob/main/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`](https://github.com/MoonshotAI/kimi-code/blob/main/AGENTS.md) (root directory) and implemented in [`packages/agent-core-v2/src/app/agent/Agent.ts`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/agent-core-v2/src/app/agent/Agent.ts). The actual language generation occurs within the LLM itself, while [`packages/kosong/src/provider.ts`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/kosong/src/provider.ts) manages which model capabilities are available based on your provider configuration.