What Programming Languages Does CRG Support Out-of-the-Box?

Code Review Graph (CRG) supports over 40 programming languages out-of-the-box, including Python, JavaScript, TypeScript, Go, Rust, Java, C/C++, C#, Ruby, Kotlin, Swift, PHP, and infrastructure formats like Terraform, Ansible, and Jupyter notebooks, all parsed through Tree-sitter and custom extractors without requiring additional configuration.

Code Review Graph (CRG) is an open-source code analysis tool that ships with a comprehensive built-in parser capable of understanding diverse programming languages and notebook formats immediately after installation. The core parser leverages Tree-sitter grammars where available and falls back to custom extractors for specialized languages, enabling seamless code review graph generation across polyglot repositories. According to the source code in code_review_graph/parser.py, the platform recognizes everything from general-purpose scripting languages to hardware description languages without any extra configuration.

Complete List of CRG Supported Programming Languages

CRG categorizes its out-of-the-box language support into five major groups, ranging from general-purpose programming languages to infrastructure-as-code formats.

General-Purpose and Scripting Languages

The core parser recognizes mainstream development languages including Python, JavaScript, TypeScript, TSX, Go, Rust, Java, C, C++, C#, VB.NET, Ruby, Kotlin, Swift, PHP, Scala, Solidity, Dart, R, Perl, Lua, Luau, Objective-C, Elixir, Zig, PowerShell, Julia, ReScript, and GDScript. Shell scripting is fully supported through bash, sh, zsh, ksh, dash, and ash parsers.

Infrastructure and Data Languages

For DevOps and data engineering workflows, CRG includes built-in support for Nix, Verilog, SystemVerilog, SQL, and Terraform/OpenTofu (.tf files). Generic .hcl files are recognized as file nodes for configuration management.

Configuration and Automation Formats

The parser handles modern web framework single-file components including Vue SFC, Svelte SFC, and Astro files (parsed through the TypeScript parser). Ansible playbooks, roles, and tasks are also supported for infrastructure automation.

Notebook and REPL Environments

CRG natively understands Jupyter and Databricks notebooks (.ipynb files), enabling code review graph generation across interactive computing environments.

Special Extensions

Unique file types such as Perl XS files (.xs) receive dedicated parsing support for native extension development.

How Language Detection Works in CRG

The language detection and parsing engine is implemented in code_review_graph/parser.py, where the CodeParser class defines the full set of built-in languages and extraction logic. According to the source code, the system employs a hybrid architecture that utilizes Tree-sitter grammars where available, providing robust syntax tree generation for accurate code analysis. When Tree-sitter grammars are unavailable for specific languages, the parser falls back to custom extractors that handle specialized syntax patterns.

Advanced Language-Specific Resolution

Beyond basic parsing, CRG implements sophisticated scoped resolution for languages with complex module and namespace systems. The code_review_graph/scoped_resolver.py file contains language-specific handling for PHP, Rust, and C#, enabling accurate dependency tracking and symbol resolution across these languages' unique scoping rules.

Verifying Installed Language Support

You can query the exact set of supported languages on your CRG installation using either the command-line interface or the Python API.

Command-Line Interface

Run the following command to display all built-in languages:

code-review-graph info --languages

Typical output includes the complete comma-separated list:

Supported languages:
  python, javascript, typescript, tsx, go, rust, java,
  c, cpp, csharp, vbnet, ruby, kotlin, swift, php,
  scala, solidity, dart, r, perl, lua, luau, objectivec,
  bash, zsh, sh, ksh, dash, ash, elixir, zig, powershell,
  julia, rescript, gdscript, nix, verilog, systemverilog,
  sql, terraform, hcl, ansible, vue, svelte, astro,
  ipynb, xs

Python API

Programmatically access the supported language set by importing the CodeParser class:

from code_review_graph.parser import CodeParser

parser = CodeParser()
print(sorted(parser.supported_languages))

This returns an ordered list matching the documentation in docs/FEATURES.md and the project README.

Summary

• CRG supports over 40 programming languages out-of-the-box without requiring plugins or configuration changes.
• The parser uses Tree-sitter for robust syntax analysis, with custom extractors as fallbacks for specialized formats.
• Language support spans general-purpose languages (Python, Rust, Go), shell scripts, infrastructure code (Terraform, Ansible), and interactive notebooks (Jupyter).
• Core implementation resides in code_review_graph/parser.py, with advanced scoping logic in code_review_graph/scoped_resolver.py.
• Users can verify available languages via code-review-graph info --languages or the CodeParser.supported_languages property.

Frequently Asked Questions

Does CRG require additional configuration to parse languages like TypeScript or Rust?

No, CRG requires zero configuration for supported languages. The CodeParser class in code_review_graph/parser.py automatically detects file extensions and applies the appropriate Tree-sitter grammar or custom extractor immediately upon installation.

Can CRG analyze Jupyter notebooks and infrastructure-as-code files?

Yes, CRG natively supports Jupyter/Databricks notebooks (.ipynb) and infrastructure formats including Terraform/OpenTofu (.tf), Ansible playbooks, and Nix expressions. These are parsed using the same core engine as general-purpose programming languages.

How does CRG handle languages without Tree-sitter grammars?

For languages lacking Tree-sitter support, CRG implements custom extractors defined in the parser module. Additionally, specialized scoping for languages like PHP, Rust, and C# is handled in code_review_graph/scoped_resolver.py to ensure accurate symbol resolution even with complex namespace hierarchies.

Where is the complete list of supported languages documented?

The authoritative list appears in three locations: the README.md at the repository root, the detailed docs/FEATURES.md documentation, and programmatically through the CodeParser.supported_languages property in code_review_graph/parser.py.

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