# What Programming Languages Does Graphify Support? A Complete Technical Guide

> Discover the extensive programming language support of Graphify, including Python, JavaScript, Java, Go, Rust, C/C++, and more. Explore our complete technical guide for deep insights.

- Repository: [Graphify Labs/graphify](https://github.com/Graphify-Labs/graphify)
- Tags: how-to-guide
- Published: 2026-07-16

---

**Graphify supports over 15 programming languages—including Python, JavaScript/TypeScript, Java, Go, Rust, C/C++, C#, Swift, Ruby, PHP, and more—through Tree-sitter grammars and a per-language resolver framework.**

Graphify is an open-source code analysis engine from Graphify-Labs/graphify designed to parse source code and generate knowledge graphs. Understanding what programming languages Graphify supports is essential for teams working with polyglot repositories who need unified symbol resolution and cross-reference analysis across their entire codebase.

## Complete List of Supported Programming Languages

Graphify uses Tree-sitter grammars and a dedicated resolver framework to parse and analyze source files. The current test suite confirms support for the following languages and language families:

- **Bash / Shell** – Validated in [`tests/test_symbol_resolution.py`](https://github.com/Graphify-Labs/graphify/blob/main/tests/test_symbol_resolution.py) (search for `"language": "bash"`)
- **Python** – Covered in [`tests/test_symbol_resolution.py`](https://github.com/Graphify-Labs/graphify/blob/main/tests/test_symbol_resolution.py) and [`tests/test_scip_ingest.py`](https://github.com/Graphify-Labs/graphify/blob/main/tests/test_scip_ingest.py)
- **JavaScript / TypeScript (JS/TS)** – Tested in [`tests/test_multilang.py`](https://github.com/Graphify-Labs/graphify/blob/main/tests/test_multilang.py) and [`tests/test_typescript_module_extensions.py`](https://github.com/Graphify-Labs/graphify/blob/main/tests/test_typescript_module_extensions.py)
- **Go** – Verified in [`tests/test_multilang.py`](https://github.com/Graphify-Labs/graphify/blob/main/tests/test_multilang.py)
- **Rust** – Verified in [`tests/test_multilang.py`](https://github.com/Graphify-Labs/graphify/blob/main/tests/test_multilang.py)
- **SQL** – Verified in [`tests/test_multilang.py`](https://github.com/Graphify-Labs/graphify/blob/main/tests/test_multilang.py)
- **Java** – Tested in [`tests/test_java_type_resolution.py`](https://github.com/Graphify-Labs/graphify/blob/main/tests/test_java_type_resolution.py) and [`tests/test_java_member_calls.py`](https://github.com/Graphify-Labs/graphify/blob/main/tests/test_java_member_calls.py)
- **C / C++** – Covered in [`tests/test_cpp_objc_cross_file_calls.py`](https://github.com/Graphify-Labs/graphify/blob/main/tests/test_cpp_objc_cross_file_calls.py)
- **Ruby** – Validated in [`tests/test_ruby_resolution.py`](https://github.com/Graphify-Labs/graphify/blob/main/tests/test_ruby_resolution.py)
- **C# / .NET** – Supported alongside XAML and .NET project files in [`tests/test_languages.py`](https://github.com/Graphify-Labs/graphify/blob/main/tests/test_languages.py)

- **Kotlin** – Verified in [`tests/test_languages.py`](https://github.com/Graphify-Labs/graphify/blob/main/tests/test_languages.py)
- **Scala** – Verified in [`tests/test_languages.py`](https://github.com/Graphify-Labs/graphify/blob/main/tests/test_languages.py)
- **PHP** – Case-insensitive resolution tested in [`tests/test_languages.py`](https://github.com/Graphify-Labs/graphify/blob/main/tests/test_languages.py)
- **Swift** – Import resolution and cross-file calls tested in [`tests/test_swift_import_resolution.py`](https://github.com/Graphify-Labs/graphify/blob/main/tests/test_swift_import_resolution.py) and [`tests/test_swift_cross_file_calls.py`](https://github.com/Graphify-Labs/graphify/blob/main/tests/test_swift_cross_file_calls.py)
- **Julia** – Verified in [`tests/test_languages.py`](https://github.com/Graphify-Labs/graphify/blob/main/tests/test_languages.py)
- **Fortran** – Verified in [`tests/test_languages.py`](https://github.com/Graphify-Labs/graphify/blob/main/tests/test_languages.py)
- **Metal Shading Language** (C++-derived) – Verified in [`tests/test_languages.py`](https://github.com/Graphify-Labs/graphify/blob/main/tests/test_languages.py)
- **Pascal** – Resolution logic tested in [`tests/test_pascal.py`](https://github.com/Graphify-Labs/graphify/blob/main/tests/test_pascal.py) and [`tests/test_pascal_resolution.py`](https://github.com/Graphify-Labs/graphify/blob/main/tests/test_pascal_resolution.py)
- **Domain-Specific Languages** – Including XAML and .NET project files in [`tests/test_languages.py`](https://github.com/Graphify-Labs/graphify/blob/main/tests/test_languages.py)

## How Language Support Is Implemented

Graphify's language support relies on three core architectural components that work together to parse files and resolve symbols.

### Tree-Sitter Grammar Integration

Each language utilizes Tree-sitter bindings for parsing. For example, TypeScript and TSX files use `language_typescript` and `language_tsx` respectively. These grammars enable Graphify to generate Abstract Syntax Trees (ASTs) that feed into the symbol extraction pipeline.

### Per-Language Resolver Registration

In [`graphify/resolver_registry.py`](https://github.com/Graphify-Labs/graphify/blob/main/graphify/resolver_registry.py), each supported language registers a `LanguageResolver` that activates when files with specific extensions appear in the corpus. This registry ensures that language-specific resolution rules (such as Python's import handling versus Java's package declarations) are applied correctly during analysis.

### Cross-Language Boundaries

Resolution passes are scoped to language families to prevent accidental edge creation across unrelated languages. The test suite validates this isolation in [`tests/test_cross_language_call_resolution.py`](https://github.com/Graphify-Labs/graphify/blob/main/tests/test_cross_language_call_resolution.py), ensuring that symbol resolution remains accurate within each language's semantic boundaries.

## Working with Multiple Languages in Graphify

You can ingest and analyze mixed-language repositories using either the Python API or the command-line interface.

### Auto-Detecting Languages via Python API

```python
import graphify

# Ingest a repository with auto-detection based on file extensions

graph = graphify.ingest_path(
    repo_path="~/my-project",
    language="auto",          # auto-detect based on file extensions

    include_patterns=["**/*"],  # ingest all files

)

# Filter nodes by specific language

python_nodes = graph.filter_nodes(lambda n: n.get("language") == "python")
print(f"Found {len(python_nodes)} Python nodes.")

```

### Using the Command-Line Interface

```bash

# Install Graphify first: pip install graphify

graphify ingest ./my-repo --language auto
graphify query 'language:python' --format json

```

### Running Language-Specific Resolvers

```python
import pathlib
from pathlib import Path

# Resolve cross-file calls within the same language family only

graphify.run_language_resolvers(
    paths=[Path(p) for p in pathlib.Path("./my-repo").rglob("*")],
    per_file=graph.per_file_data,
    all_nodes=graph.nodes,
    all_edges=graph.edges,
)

```

## Summary

- **Graphify supports 15+ languages** ranging from systems languages (Rust, C/C++, Go) to web stacks (JavaScript/TypeScript, PHP, Ruby) and JVM ecosystems (Java, Kotlin, Scala).
- **Tree-sitter powers parsing** for all supported languages, providing consistent AST generation across different syntaxes.
- **Per-language resolvers** in [`graphify/resolver_registry.py`](https://github.com/Graphify-Labs/graphify/blob/main/graphify/resolver_registry.py) handle language-specific semantics while preventing cross-language contamination.
- **Auto-detection** works via file extensions, allowing seamless analysis of polyglot repositories without manual configuration.

## Frequently Asked Questions

### Does Graphify support C# and .NET projects?

Yes. Graphify handles C# source files along with XAML and .NET project files. The test suite in [`tests/test_languages.py`](https://github.com/Graphify-Labs/graphify/blob/main/tests/test_languages.py) specifically validates C# symbol extraction and resolution within .NET ecosystems.

### How does Graphify handle TypeScript versus JavaScript?

Graphify treats JavaScript and TypeScript as part of the same language family but uses distinct Tree-sitter grammars (`language_typescript` for `.ts` files and `language_tsx` for `.tsx` files). This allows the parser to handle TypeScript-specific syntax like interfaces and generics while maintaining cross-file resolution between `.js` and `.ts` modules.

### Can Graphify analyze multiple languages in the same repository?

Yes. Graphify is designed for polyglot repositories. When you set `language="auto"` in the API or CLI, Graphify identifies file types by extension and activates the appropriate `LanguageResolver` for each file. The resolution framework ensures symbols resolve within their respective language families, as verified by [`tests/test_cross_language_call_resolution.py`](https://github.com/Graphify-Labs/graphify/blob/main/tests/test_cross_language_call_resolution.py).

### What parser does Graphify use for language support?

Graphify uses Tree-sitter grammars for all supported languages. This parser generator provides incremental parsing capabilities and consistent AST structures across languages, enabling Graphify to extract symbols and generate knowledge-graph edges uniformly regardless of the source language.