tree-sitter-language-pack¶

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

Quick Start Installation GitHub

Why tree-sitter-language-pack?¶

170+ Languages

Parse Python, JavaScript, Rust, Go, Java, C, TypeScript, Ruby, and 165+ 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 is battle-tested in editors like Neovim and Helix for a reason.

Architecture overview

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

const { process } = require("@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"
    tslp "github.com/kreuzberg-dev/tree-sitter-language-pack/packages/go/v1"
)

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

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

    fmt.Println("Root:", tree.RootNodeType())
}

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
use TreeSitterLanguagePack\LanguagePack;

LanguagePack::init(json_encode(['languages' => ['php']]));

$tree = LanguagePack::parseString('php', '<?php function hello() { echo "world"; } ?>');
echo "Root: " . $tree->rootNodeType() . "\n";

WebAssembly

import { availableLanguages, parseString } 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: ${tree.rootNodeType()}`);

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/v1

<dependency>
  <groupId>dev.kreuzberg</groupId>
  <artifactId>tree-sitter-language-pack</artifactId>
  <version>1.0.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/v1`	1.26+
Java	`dev.kreuzberg:tree-sitter-language-pack`	21+
C# / .NET	`TreeSitterLanguagePack`	.NET 10+
Ruby	`tree_sitter_language_pack`	3.4+
:material-language-elixir: 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`	—