What Programming Languages Does Kimi Code Support?

Kimi Code is language-agnostic and supports any programming language the underlying LLM model can generate, including JavaScript/TypeScript, Python, Go, Rust, Java, C#, and many others.

Kimi Code, developed by MoonshotAI, takes a deliberately language-agnostic approach to code generation according to the repository source. Instead of maintaining a fixed list of supported syntaxes, the system forwards natural-language requests directly to the underlying LLM model. This architecture means programming languages in kimi-code applications are determined entirely by the capabilities of the selected provider's model.

Language-Agnostic Architecture

The repository does not ship with a hard-coded list of supported programming languages. Instead, language handling is performed by the model itself through the agent system.

In packages/agent-core-v2/src/app/agent/Agent.ts, the core Agent class receives prompts and forwards them to the model. The system prompt defined in AGENTS.md (line 9) explicitly instructs: "Write in the user's language … Keep code, commands, identifiers, file paths, and technical terms in their original form". This directive forces the agent to preserve the exact syntax and structure of the code without imposing language-specific restrictions.

Because the LLM performs the actual code generation, Kimi Code can theoretically handle any programming language the model was trained on, from mainstream languages like Python and JavaScript to specialized languages like Rust, Julia, or even legacy languages like COBOL.

Provider Configuration and Language Capabilities

While the codebase itself is language-agnostic, the effective programming languages available depend on the provider configuration.

The packages/kosong/src/provider.ts file defines the provider abstraction that selects which LLM model handles requests. Each model advertises specific capabilities—such as vision, tool use, and code generation—through its configuration. When a model declares support for a specific language (e.g., "code generation for Go"), Kimi Code automatically enables that capability.

You configure the provider and model in config.toml, documented in docs/en/configuration/providers.md. The model you select becomes the ultimate arbiter of which programming languages are effectively supported in your kimi-code installation.

Practical Examples Across Languages

The CLI entry point at apps/kimi-code/src/cli.ts parses the --prompt flag and sends requests to the Agent. Here are concrete examples demonstrating how kimi-code handles different programming languages through natural-language prompts.

TypeScript Utility Generation

Request a TypeScript function using the CLI:

# Ask Kimi Code to create a TS file that capitalises a string

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

The model generates standard TypeScript syntax:

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

Python Data Processing Script

Request Python code for CSV processing:

# Ask Kimi Code to write a Python script that reads a CSV file and prints the sum of a column named “price”.

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"))

These examples demonstrate that the target language is dictated by the natural-language prompt, not by a configuration setting in the codebase.

Key Source Files

Several files implement this language-agnostic architecture:

• packages/agent-core-v2/src/app/agent/Agent.ts: Core Agent class that receives prompts and forwards them to the model; language handling occurs via system prompts.
• packages/kosong/src/provider.ts: Provider abstraction that selects the LLM model and queries its advertised capabilities.
• apps/kimi-code/src/cli.ts: CLI entry point (kimi command) that parses the --prompt flag and routes requests.
• AGENTS.md: Root documentation defining the system-prompt rules that enforce language preservation.
• docs/en/configuration/providers.md: Documentation explaining how provider configuration determines model selection and effective language support.

Summary

• Kimi Code supports any programming language the selected LLM model can generate, with no hard-coded language list in the repository.
• Language support is determined by the provider configuration in config.toml and the capabilities of the chosen model in packages/kosong/src/provider.ts.
• The system prompt in AGENTS.md enforces language preservation, keeping code identifiers and technical terms in their original form.
• Users specify the desired programming language through natural-language prompts parsed by apps/kimi-code/src/cli.ts.

Frequently Asked Questions

Does Kimi Code support niche programming languages like Fortran or COBOL?

Yes, provided the underlying LLM model was trained on that language. Since Kimi Code forwards requests to the model without language restrictions implemented in packages/agent-core-v2/src/app/agent/Agent.ts, it can generate code for any language within the model's training data, including legacy or specialized languages.

How do I configure which programming languages are available in my Kimi Code installation?

Language availability is controlled through the provider configuration. By selecting a specific model in config.toml (as documented in docs/en/configuration/providers.md), you determine which programming languages are effectively supported. The packages/kosong/src/provider.ts file handles the abstraction that queries each model's advertised capabilities.

Can Kimi Code translate code between different programming languages?

Yes. Because the LLM understands multiple languages, you can request translation by asking the model to convert code from one language to another in your prompt. The CLI at apps/kimi-code/src/cli.ts passes this request directly to the Agent, which leverages the model's cross-language capabilities.

Is there a limit to how many programming languages I can use in a single Kimi Code session?

There is no arbitrary limit enforced by the codebase. You can request code in different languages within the same session, and the system will generate each according to the model's capabilities. The limitation is purely the model's ability to handle multiple language contexts accurately, not a restriction in the kimi-code implementation.

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