# What Programming Languages Does CocoIndex Support?

> Discover the programming languages CocoIndex supports. Our Rust-based module automatically identifies hundreds of languages and markup formats using file extensions.

- Repository: [CocoIndex/cocoindex](https://github.com/cocoindex-io/cocoindex)
- Tags: about
- Published: 2026-05-05

---

**CocoIndex automatically recognizes hundreds of programming languages and markup formats by analyzing file extensions through its Rust-based language detection module.**

The `cocoindex-io/cocoindex` repository maintains a comprehensive language registry that powers syntax-aware text processing capabilities. Understanding what programming languages CocoIndex supports enables developers to leverage automatic language identification for intelligent code chunking, parsing, and analysis pipelines.

## Language Detection Architecture

CocoIndex implements language detection through a static registry compiled into the Rust core, exposing functionality to Python via PyO3 bindings.

### The Static Registry in [`prog_langs.rs`](https://github.com/cocoindex-io/cocoindex/blob/main/prog_langs.rs)

The central authority for supported languages resides in **[`rust/ops_text/src/prog_langs.rs`](https://github.com/cocoindex-io/cocoindex/blob/main/rust/ops_text/src/prog_langs.rs)**. This module defines `LANGUAGE_INFO_BY_NAME`, a thread-safe static map populated at compile time:

```rust
static LANGUAGE_INFO_BY_NAME: LazyLock<HashMap<…, Arc<ProgrammingLanguageInfo>>> = 
    LazyLock::new(|| {
        let mut map = HashMap::new();
        // Series of add() calls registering each language
        // e.g., add("rust", &[".rs", "rs"], Some(TreeSitterLanguageInfo::new(...)))
        map
    });

```

Each language entry registers via the `add()` helper, specifying the canonical name, valid file extensions, and optional Tree-sitter grammar configurations. The registry contains approximately 250 entries covering mainstream and niche programming languages.

### Core Detection Logic

Language identification occurs through two primary functions in [`prog_langs.rs`](https://github.com/cocoindex-io/cocoindex/blob/main/prog_langs.rs) (lines 14-30):

- **`get_language_info(name)`** – Performs case-insensitive HashMap lookups against the static registry
- **`detect_language(filename: &str) -> Option<&str>`** – Extracts the extension using `rfind('.')` and delegates to `get_language_info`

If the extension matches a registered language, the function returns the canonical language name (e.g., `"python"`); otherwise, it returns `None`.

### Python API Bindings

The Rust detection logic exposes functionality to Python through **[`rust/py/src/ops.rs`](https://github.com/cocoindex-io/cocoindex/blob/main/rust/py/src/ops.rs)**:

```rust
pub fn detect_code_language(filename: &str) -> Option<String> {
    prog_langs::detect_language(filename).map(|s| s.to_string())
}

```

This function registers in **[`rust/py/src/lib.rs`](https://github.com/cocoindex-io/cocoindex/blob/main/rust/py/src/lib.rs)** via PyO3's `wrap_pyfunction` macro, making it available as **`cocoindex.ops.detect_code_language()`**. The Python wrapper maintains the same semantics: it returns a language string or `None` for unrecognized extensions.

## Supported Programming Languages and File Extensions

CocoIndex recognizes languages by their file extensions and common aliases. While the complete list spans roughly 250 entries in the source, representative supported languages include:

| Language | Recognized Extensions |
|----------|---------------------|
| **Rust** | `.rs`, `rs` |
| **Python** | `.py`, `.pyw`, `.pyi`, `.pyx`, `.pxd`, `.pxi` |
| **JavaScript** | `.js`, `.cjs`, `.mjs`, `js` |
| **TypeScript** | `.ts`, `ts` |
| **C / C++** | `.c`, `.h`, `.cpp`, `.hpp`, `c++` |
| **C#** | `.cs`, `cs`, `c#` |
| **Java** | `.java`, `.jav`, `.jsh` |
| **Go** | `.go`, `golang` |
| **Kotlin** | `.kt`, `.ktm`, `.kts` |
| **Swift** | `.swift` |
| **Ruby** | `.rb` |
| **PHP** | `.php` |
| **Julia** | `.jl` |
| **Scala** | `.scala` |
| **Haskell** | `.hs`, `.hs-boot`, `.hsc` |
| **HTML** | `.html`, `.htm`, `.xhtml` |
| **Markdown** | `.md`, `.markdown`, `.mdx` |
| **SQL** | `.sql` |
| **YAML / TOML** | `.yaml`, `.yml`, `.toml` |
| **Svelte** | `.svelte` |
| **Vue** | `.vue` |
| **GraphQL** | `.graphql`, `.gql` |
| **Dockerfile** | `Dockerfile`, `.dockerfile` |
| **Makefile** | `.mk`, `Makefile` |

Each entry optionally includes a **Tree-sitter grammar** reference, enabling syntax-aware chunking capabilities in [`rust/ops_text/src/recursive.rs`](https://github.com/cocoindex-io/cocoindex/blob/main/rust/ops_text/src/recursive.rs).

## Practical Usage Examples

### Detecting Languages from Filenames

Use the Python API to identify programming languages programmatically:

```python
from cocoindex import ops

# Returns canonical language identifiers

print(ops.detect_code_language("main.rs"))       # → "rust"

print(ops.detect_code_language("script.py"))     # → "python"

print(ops.detect_code_language("app.ts"))        # → "typescript"

print(ops.detect_code_language("styles.css"))    # → "css"

print(ops.detect_code_language("unknown.xyz"))   # → None

```

### Enabling Syntax-Aware Text Splitting

CocoIndex leverages automatic language detection for intelligent code chunking:

```python
from cocoindex import ops, RecursiveSplitter

# Configure splitter with auto-detection (language=None)

splitter = RecursiveSplitter(chunk_size=500, language=None)

# Process mixed file types

files = ["src/main.rs", "README.md", "config.yaml"]

# Internal implementation calls detect_code_language() 

# to select appropriate Tree-sitter grammars for each file

```

The `RecursiveSplitter` internally invokes `detect_code_language` to match file extensions against the registry, applying language-specific parsing rules when Tree-sitter grammars are available.

## Summary

- CocoIndex supports **hundreds of programming languages** through a static registry defined in [`rust/ops_text/src/prog_langs.rs`](https://github.com/cocoindex-io/cocoindex/blob/main/rust/ops_text/src/prog_langs.rs)
- Language detection relies on **`detect_language()`**, which maps file extensions to canonical language names using a case-insensitive HashMap lookup
- Python developers access detection via **`cocoindex.ops.detect_code_language(filename)`**, a thin PyO3 wrapper around the Rust implementation
- Each registry entry may include **Tree-sitter grammar** metadata, enabling syntax-aware chunking for supported languages
- Unrecognized file extensions return `None`, allowing graceful fallback to language-agnostic processing

## Frequently Asked Questions

### How many programming languages does CocoIndex support?

CocoIndex recognizes approximately **250 programming languages and markup formats**, ranging from mainstream languages like Python, JavaScript, and Rust to specialized formats like Svelte, GraphQL, and various configuration file syntaxes. The complete authoritative list resides in the static initialization block of [`rust/ops_text/src/prog_langs.rs`](https://github.com/cocoindex-io/cocoindex/blob/main/rust/ops_text/src/prog_langs.rs).

### What file attributes does CocoIndex use to detect programming languages?

CocoIndex detects languages exclusively through **file extensions**. The `detect_language()` function extracts the substring after the final period using `rfind('.')` and performs a lookup in the `LANGUAGE_INFO_BY_NAME` registry. Both standard extensions (`.py`) and common aliases (`py`) are supported for many languages.

### Can I use CocoIndex language detection without Tree-sitter support?

Yes. While many registry entries include optional `TreeSitterLanguageInfo` for syntax-aware parsing, the **`detect_language()`** function operates independently of Tree-sitter grammars. You can identify file types for organizational or routing purposes even when Tree-sitter chunking is not required.

### How do I check if a specific file type is supported by CocoIndex?

Import the detection function and test your specific filename or extension:

```python
from cocoindex import ops
result = ops.detect_code_language("my_file.xyz")

# Returns the language string if supported, None otherwise

```

If the function returns `None`, the extension is not registered in the current version's language map. You can also inspect the source file [`rust/ops_text/src/prog_langs.rs`](https://github.com/cocoindex-io/cocoindex/blob/main/rust/ops_text/src/prog_langs.rs) to verify whether specific extensions appear in the `add()` calls within the static initialization code.