What Programming Languages Does Graphify Support? A Complete Technical Guide

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 (search for "language": "bash")

• Python – Covered in tests/test_symbol_resolution.py and tests/test_scip_ingest.py

• JavaScript / TypeScript (JS/TS) – Tested in tests/test_multilang.py and tests/test_typescript_module_extensions.py

• Go – Verified in tests/test_multilang.py

• Rust – Verified in tests/test_multilang.py

• SQL – Verified in tests/test_multilang.py

• Java – Tested in tests/test_java_type_resolution.py and tests/test_java_member_calls.py

• C / C++ – Covered in tests/test_cpp_objc_cross_file_calls.py

• Ruby – Validated in tests/test_ruby_resolution.py

• C# / .NET – Supported alongside XAML and .NET project files in tests/test_languages.py

• Kotlin – Verified in tests/test_languages.py

• Scala – Verified in tests/test_languages.py

• PHP – Case-insensitive resolution tested in tests/test_languages.py

• Swift – Import resolution and cross-file calls tested in tests/test_swift_import_resolution.py and tests/test_swift_cross_file_calls.py

• Julia – Verified in tests/test_languages.py

• Fortran – Verified in tests/test_languages.py

• Metal Shading Language (C++-derived) – Verified in tests/test_languages.py

• Pascal – Resolution logic tested in tests/test_pascal.py and tests/test_pascal_resolution.py

• Domain-Specific Languages – Including XAML and .NET project files in 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, 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, 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

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

# Install Graphify first: pip install graphify

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

Running Language-Specific Resolvers

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 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 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.

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.

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