tree-sitter-language-pack

Universal code parser for 305 languages — parse, analyze, and chunk source code across every major programming language.

Quick Start Installation GitHub

Why tree-sitter-language-pack?¶

305 Languages

Parse Python, JavaScript, Rust, Go, Java, C, TypeScript, Ruby, and 240+ more with a single unified API. One dependency, every language.

See all languages
Download on Demand

Parsers are downloaded and cached automatically on first use. No bloated installs — only fetch what you need.

Learn about the download model
Code Intelligence

Extract functions, classes, imports, exports, comments, docstrings, and symbols — not just raw syntax trees.

Code intelligence concepts
Syntax-Aware Chunking

Split code at natural boundaries for LLMs. Never break a function in half or separate a decorator from its definition.

Chunking for LLMs
Available Everywhere

Python, Node.js, Rust, Go, Java, C#, Ruby, Elixir, PHP, WebAssembly, CLI — same API, all platforms.

Installation guide
Native Performance

Rust core with zero-copy parsing. Tree-sitter powers production editors including Neovim, Helix, and Zed.

Architecture overview
Extraction Queries

Run custom tree-sitter queries and get structured results with text, metadata, and child fields.

Extraction guide

Quick Example¶

PythonNode.jsRustGoJavaC#RubyElixirPHPWASMCLI

Python

import tree_sitter_language_pack as tslp

# Parsers download automatically on first use
result = tslp.process(
    "def hello():\n    print('world')\n",
    tslp.ProcessConfig(language="python", structure=True, imports=True),
)

print(f"Language: {result['language']}")
print(f"Functions: {len(result['structure'])}")

Node.js

import { process } from "@kreuzberg/tree-sitter-language-pack";

const result = process(
  "function hello() { console.log('world'); }",
  { language: "javascript", structure: true, imports: true },
);

console.log(`Language: ${result.language}`);
console.log(`Functions: ${result.structure.length}`);

Rust

use tree_sitter_language_pack::{ProcessConfig, process};

fn main() -> anyhow::Result<()> {
    let config = ProcessConfig::new("rust").all();
    let result = process("fn main() { println!(\"hello\"); }", &config)?;

    println!("Language: {}", result.language);
    println!("Functions: {}", result.structure.len());
    Ok(())
}

Go

package main

import (
    "fmt"
    "log"
    tslp "github.com/kreuzberg-dev/tree-sitter-language-pack/packages/go"
)

func main() {
    registry, _ := tslp.NewRegistry()
    defer registry.Close()

    tree, _ := registry.ParseString("go", "package main\nfunc hello() {}")
    defer tree.Close()

    rootType, err := tree.RootNodeType()
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Root:", rootType)
}

Java

import io.github.treesitter.languagepack.TsPackRegistry;

class Main {
    public static void main(String[] args) {
        TsPackRegistry.init("{\"languages\": [\"java\"]}");

        var tree = TsPackRegistry.parseString("java", "class Foo { void bar() {} }");
        System.out.println("Root: " + tree.rootNodeType());
    }
}

C#

using System;
using TreeSitterLanguagePack;

class Program
{
    static void Main()
    {
        TsPackClient.Init("{\"languages\": [\"csharp\"]}");

        var tree = TsPackClient.ParseString("csharp", "class Foo { void Bar() {} }");
        Console.WriteLine($"Root: {tree.RootNodeType()}");
    }
}

Ruby

require "tree_sitter_language_pack"

TreeSitterLanguagePack.init('{"languages": ["ruby"]}')

tree = TreeSitterLanguagePack.parse_string("ruby", "def hello; puts 'world'; end")
puts "Root: #{tree.root_node_type}"

Elixir

TreeSitterLanguagePack.init(~s({"languages": ["elixir"]}))

{:ok, tree} = TreeSitterLanguagePack.parse_string("elixir", "defmodule M do end")
{:ok, node_type} = TreeSitterLanguagePack.tree_root_node_type(tree)
IO.puts("Root: #{node_type}")

PHP

<?php
if (\ts_pack_has_language("php")) {
    $sexp = \ts_pack_parse_string("php", '<?php function hello() { echo "world"; } ?>');
    echo "Tree: $sexp\n";
}

WebAssembly

import { availableLanguages, parseString, treeRootNodeType } from "@kreuzberg/tree-sitter-language-pack-wasm";

const langs = availableLanguages();
console.log(`${langs.length} languages available`);

const tree = parseString("python", "def hello(): pass");
console.log(`Root: ${treeRootNodeType(tree)}`);

CLI

# Download parsers
ts-pack download python javascript rust

# Parse a file
ts-pack parse main.py --format json

# Run code intelligence
ts-pack process src/app.py --all

# List available languages
ts-pack list --manifest

Install¶

PythonNode.jsRustGoJavaCLI

pip install tree-sitter-language-pack

uv add tree-sitter-language-pack

npm install @kreuzberg/tree-sitter-language-pack

pnpm add @kreuzberg/tree-sitter-language-pack

cargo add ts-pack-core

go get github.com/kreuzberg-dev/tree-sitter-language-pack/packages/go

<dependency>
  <groupId>dev.kreuzberg</groupId>
  <artifactId>tree-sitter-language-pack</artifactId>
  <version>1.3.0</version>
</dependency>

# Homebrew (macOS / Linux)
brew install kreuzberg-dev/tap/ts-pack

# Cargo
cargo install ts-pack

Supported Ecosystems¶

Ecosystem	Package	Minimum Version
Python	`tree-sitter-language-pack`	3.10+
Node.js	`@kreuzberg/tree-sitter-language-pack`	18+
Rust	`ts-pack-core`	1.75+
Go	`packages/go`	1.26+
Java	`dev.kreuzberg:tree-sitter-language-pack`	25+
C# / .NET	`TreeSitterLanguagePack`	.NET 10+
Ruby	`tree_sitter_language_pack`	3.4+
Elixir	`tree_sitter_language_pack`	1.14+ / OTP 25+
PHP	`kreuzberg/tree-sitter-language-pack`	8.2+
WebAssembly	`@kreuzberg/tree-sitter-language-pack-wasm`	Browser / Deno
CLI	`ts-pack`	—

tree-sitter-language-pack is part of the kreuzberg.dev open-source ecosystem.