# Code-Graph-RAG Supported Languages: 14 Programming Languages and Their Capabilities

> Explore Code-Graph-RAG's 14 supported programming languages, including Python, Java, and JavaScript. Understand their capabilities and how Tree-sitter creates a unified knowledge graph.

- Repository: [Vitali Avagyan/code-graph-rag](https://github.com/vitali87/code-graph-rag)
- Tags: supported-languages
- Published: 2026-08-20

---

**Code-Graph-RAG supports 14 programming languages including C, C#, C++, Dart, Go, Java, JavaScript, Lua, PHP, Python, Rust, TypeScript, TypeScript-TSX, and Scala (in development), all parsed through Tree-sitter into a unified, language-agnostic knowledge graph.**

Code-Graph-RAG is an open-source retrieval-augmented generation (RAG) engine for codebases that builds cross-language knowledge graphs. Understanding which **Code-Graph-RAG supported languages** are available—and what capabilities each offers—is essential for teams working with polyglot codebases.

## How Code-Graph-RAG Achieves Language Agnosticism

The engine relies on **Tree-sitter**, a fast incremental parser that produces a uniform abstract syntax tree (AST) for any language with a Tree-sitter grammar. This eliminates the need for language-specific parsers and enables a single graph schema across all supported languages.

In [`codebase_rag/language_spec.py`](https://github.com/vitali87/code-graph-rag/blob/main/codebase_rag/language_spec.py), the `LanguageSpec` class handles three critical tasks:

1. **Grammar discovery** – Loads the appropriate Tree-sitter grammar for each language
2. **Extension registration** – Maps file extensions to their corresponding parsers
3. **AST-to-graph mapping** – Converts language-specific AST nodes into unified graph entities (functions, classes, modules, etc.)

This architecture means a Cypher query written for Python functions works identically for Rust functions, Java methods, or Go receiver methods.

## Complete Language Support Matrix

The authoritative source for **Code-Graph-RAG supported languages** is [`docs/architecture/language-support.md`](https://github.com/vitali87/code-graph-rag/blob/main/docs/architecture/language-support.md). The table below reflects the current coverage as implemented in the repository:

### Fully Supported Languages (13)

| Language | Extensions | Functions | Classes/Structs | Modules | Package Detection | Key Capabilities |
|----------|-----------|-----------|-----------------|---------|-------------------|----------------|
| **C** | `.c` | ✓ | ✓ | ✓ | ✓ | Functions, structs, unions, enums, pre-processor includes |
| **C#** | `.cs` | ✓ | ✓ | ✓ | – | Namespaces, classes/structs/records/interfaces/enums, generics, inheritance, using directives |
| **C++** | `.cpp`, `.h`, `.hpp`, `.cc` | ✓ | ✓ | ✓ | ✓ | Constructors, destructors, operator overloading, templates, lambdas, C++20 modules, pre-processor macros |
| **Dart** | `.dart` | ✓ | ✓ | ✓ | – | Classes, mixins, extensions, enhanced enums, Flutter widgets, package/relative imports |
| **Go** | `.go` | ✓ | ✓ | ✓ | – | Receiver methods, structs, interfaces, type declarations |
| **Java** | `.java` | ✓ | ✓ | ✓ | – | Generics, annotations, records, sealed classes, concurrency constructs |
| **JavaScript** | `.js`, `.jsx`, `.mjs`, `.cjs` | ✓ | ✓ | ✓ | – | ES6 modules, CommonJS, prototype & object methods, arrow functions |
| **Lua** | `.lua` | ✓ | – | ✓ | – | Local/global functions, metatables, closures, coroutines |
| **PHP** | `.php` | ✓ | ✓ | ✓ | – | Classes, interfaces, traits, enums, namespaces, PHP 8 attributes |
| **Python** | `.py` | ✓ | ✓ | ✓ | ✓ | Type inference, decorators, nested functions |
| **Rust** | `.rs` | ✓ | ✓ | ✓ | ✓ | `impl` blocks, associated functions, `macro_rules!` macros |
| **TypeScript** | `.ts`, `.mts`, `.cts` | ✓ | ✓ | ✓ | – | Interfaces, type aliases, enums, namespaces, ES6/CommonJS modules |
| **TypeScript (TSX)** | `.tsx` | ✓ | ✓ | ✓ | – | Full TypeScript plus JSX components |

### In Development (1)

| Language | Extensions | Functions | Classes/Structs | Modules | Status Notes |
|----------|-----------|-----------|-----------------|---------|--------------|
| **Scala** | `.scala`, `.sc` | ✓ | ✓ | ✓ | Case classes, objects—parsing implementation incomplete |

## Language-Specific Capabilities Deep-Dive

### Systems Languages: C, C++, Rust

These languages receive comprehensive low-level support. **C++** parsing in [`codebase_rag/language_spec.py`](https://github.com/vitali87/code-graph-rag/blob/main/codebase_rag/language_spec.py) handles modern C++20 modules alongside traditional templates and lambdas. **Rust** support captures `impl` blocks and associated functions—critical for understanding ownership patterns. Both C and C++ include **package detection** via header/include analysis.

### JVM Languages: Java, Scala

**Java** support covers modern language features including records, sealed classes, and generics. The **Scala** integration is actively developed, with case classes and singleton objects already recognized in the AST mapping.

### Web/Node.js Ecosystem: JavaScript, TypeScript, TSX

Code-Graph-RAG distinguishes between **TypeScript** (`.ts`, `.mts`, `.cts`) and **TypeScript-TSX** (`.tsx`) as separate entries. Both support full type system constructs—interfaces, type aliases, namespaces—while TSX adds JSX component detection. **JavaScript** handles both ES6 modules and CommonJS seamlessly.

### Mobile & Specialized: Dart, Go, Lua, PHP

- **Dart** – Flutter widget detection and mixin/extension support
- **Go** – Receiver method parsing distinguishes between value and pointer receivers
- **Lua** – Unique among supported languages for lacking class constructs; focuses on function-level analysis with closure detection
- **PHP** – Modern PHP 8 attributes and trait composition are fully parsed

### Python: Deep Language Integration

**Python** receives enhanced treatment with **type inference** and decorator chain parsing. The [`codebase_rag/constants/languages.py`](https://github.com/vitali87/code-graph-rag/blob/main/codebase_rag/constants/languages.py) file includes Python-specific AST node mappings that capture nested function scopes—uncommon in other language implementations.

## Working with the Language Support System

### Loading a Multi-Language Repository

```python
from codebase_rag import CodeGraphRAG

# Automatically detects all supported languages in the repository

cgr = CodeGraphRAG(root_path="/path/to/polyglot_repo")
cgr.build_graph()  # Parses files based on registered extensions

```

This initializes the engine with default configuration enabling all **Code-Graph-RAG supported languages** from [`codebase_rag/constants/languages.py`](https://github.com/vitali87/code-graph-rag/blob/main/codebase_rag/constants/languages.py).

### Running Language-Agnostic Queries

```python

# Find all functions named "validate" across any supported language

query = """
MATCH (f:Function {name: "validate"})
RETURN f.language, f.file_path, f.start_line, f.end_line
"""
results = cgr.query_cypher(query)

for r in results:
    print(f"[{r['language']}] {r['file_path']}:{r['start_line']}-{r['end_line']}")

```

The `language` property on every graph node enables filtering or aggregation by source language without modifying the query structure.

### CLI Export for Specific Languages

```bash

# Export only Python and Rust files from a mixed codebase

python -m codebase_rag.cli export-graph \
    --root /path/to/project \
    --include-ext .py,.rs \
    --output python_rust_graph.json

```

The CLI in [`codebase_rag/cli.py`](https://github.com/vitali87/code-graph-rag/blob/main/codebase_rag/cli.py) respects the same extension-to-language mappings defined in the core language spec.

## Extending Language Support

Adding new languages is designed to be straightforward. The repository's *Adding Languages* guide (referenced in [`docs/architecture/language-support.md`](https://github.com/vitali87/code-graph-rag/blob/main/docs/architecture/language-support.md)) specifies that any language with an existing Tree-sitter grammar requires only:

1. Grammar package installation
2. Extension registration in [`codebase_rag/constants/languages.py`](https://github.com/vitali87/code-graph-rag/blob/main/codebase_rag/constants/languages.py)
3. AST node type mapping in [`codebase_rag/language_spec.py`](https://github.com/vitali87/code-graph-rag/blob/main/codebase_rag/language_spec.py)

The `LanguageSpec` class automatically discovers and registers new grammars through this configuration-driven approach.

## Summary

- **Code-Graph-RAG supported languages** total 14: 13 fully supported (C, C#, C++, Dart, Go, Java, JavaScript, Lua, PHP, Python, Rust, TypeScript, TypeScript-TSX) plus Scala in active development
- **Tree-sitter foundation** provides uniform AST parsing across all languages
- **Unified graph schema** enables truly language-agnostic Cypher queries
- **Deep language features** are captured per-language: C++ templates, Rust macros, Python decorators, TypeScript interfaces, etc.
- **Extension capability** allows straightforward addition of any Tree-sitter grammar

## Frequently Asked Questions

### What makes Code-Graph-RAG "language-agnostic"?

The engine maps every language's AST into a **single graph schema** with common entity types: `Function`, `Class`, `Module`, `Package`. A query for functions returns results from Python, Rust, Java, or any combination without syntax changes. This polyglot design is implemented in [`codebase_rag/language_spec.py`](https://github.com/vitali87/code-graph-rag/blob/main/codebase_rag/language_spec.py) through unified node type mappings.

### Why is Scala listed as "in development" while other languages are fully supported?

Scala's complex type system and syntactic flexibility require additional AST node mappings that are incomplete as of the current repository state. The [`docs/architecture/language-support.md`](https://github.com/vitali87/code-graph-rag/blob/main/docs/architecture/language-support.md) file indicates that case classes and objects are partially implemented, but full pattern matching and implicits coverage remains under development.

### Can I query across multiple languages in a single operation?

Yes. The graph schema deliberately shares entity types across languages, so `MATCH (f:Function) WHERE f.name = "main"` returns the `main` function from C, Go, Rust, or any supported language in the same query. The `language` property on each node allows post-filtering if needed.

### How does package detection work for languages that support it?

Package detection is implemented for C, C++, Python, and Rust. For C/C++, it analyzes `#include` directives and header guards. For Python, it parses [`__init__.py`](https://github.com/vitali87/code-graph-rag/blob/main/__init__.py) structures and relative imports. For Rust, it maps `mod` declarations and [`Cargo.toml`](https://github.com/vitali87/code-graph-rag/blob/main/Cargo.toml) workspace membership. This information feeds into the `Package` node type in the unified graph.