Quick Start

This guide walks you from install to parsing, code intelligence, and LLM chunking.

---

1. Install

Python

pip install tree-sitter-language-pack

Node.js

npm install @xberg-io/tree-sitter-language-pack

Rust

cargo add tree-sitter-language-pack

CLI

brew tap xberg-io/homebrew-tap
brew install xberg-io/homebrew-tap/ts-pack

Other ecosystems

Go, Java, C#, Ruby, Elixir, PHP, Dart, Kotlin Android, Swift, Zig, C FFI, and WebAssembly are also supported. See Installation for the full list.

---

2. Download Parsers

Parsers download automatically on first use. For production, CI, Docker, or offline environments, pre-download them.

Specific languages

CLI

CLI

# Download specific languages
ts-pack download python javascript rust go

# Download all available languages
ts-pack download --all

# Download a language group (the manifest currently defines only "all")
ts-pack download --groups all

# Fresh download (clear cache first)
ts-pack download --fresh python

# Check what's cached
ts-pack list --downloaded

Python

Download a single language parser and verify count

Python

from tree_sitter_language_pack import download

def main() -> None:
    names = ["python"]
    result = download(names)
    print(result)

main()

Node.js

Download a single language parser and verify count

TypeScript

import { download } from "@xberg-io/tree-sitter-language-pack";
function main() {
  const result = download(["python"]);
  console.log(result);
}

void main();

Ruby

Download a single language parser and verify count

Ruby

require "tree_sitter_language_pack"
result = TreeSitterLanguagePack.download(['python'])
puts result.inspect

PHP

Download a single language parser and verify count

PHP

<?php

declare(strict_types=1);

require_once __DIR__ . '/vendor/autoload.php';

use Tree\Sitter\Language\Pack\TreeSitterLanguagePack;
$result = TreeSitterLanguagePack::download(["python"]);
var_dump($result);

Go

Download a single language parser and verify count

Go

package main

import (
  "encoding/json"
  "fmt"
  tspack "github.com/xberg-io/tree-sitter-language-pack/packages/go"
)

func main() {
  var names []string
  if err := json.Unmarshal([]byte(`["python"]`), &names); err != nil {
    panic(fmt.Sprintf("config parse failed: %v", err))
  }
  result, err := tspack.Download(names)
  if err != nil {
    panic(err)
  }
  fmt.Printf("%+v\n", result)
}

Java

Download a single language parser and verify count

Java

import io.xberg.treesitterlanguagepack.*;

public final class Example {
    public static void main(String[] args) throws Exception {
        var result = TreeSitterLanguagePack.download(java.util.List.of("python"));
        System.out.println(result);
    }
}

C#

Download a single language parser and verify count

C#

using System;
using System.Text.Json;
using TreeSitterLanguagePack;

var ConfigOptions = new JsonSerializerOptions { PropertyNameCaseInsensitive = true };
var result = TreeSitterLanguagePackConverter.Download(new List<String>() { JsonSerializer.Deserialize<String>("\"python\"", ConfigOptions)! });
Console.WriteLine(result);

Elixir

Download a single language parser and verify count

Elixir

result = TreeSitterLanguagePack.download(["python"])
IO.inspect(result)

Dart

Download a single language parser and verify count

Dart

import 'dart:io';
import 'package:tree_sitter_language_pack/tree_sitter_language_pack.dart';
import 'package:tree_sitter_language_pack/src/tree_sitter_language_pack_bridge_generated/frb_generated.dart' show RustLib;
Future<void> main() async {
  await RustLib.init();
  try {
    final result = await TreeSitterLanguagePackBridge.download(<String>['python']);
    stdout.writeln(result);
  } finally {
    RustLib.dispose();
  }
}

Swift

Download a single language parser and verify count

Swift

import TreeSitterLanguagePack

let result = try TreeSitterLanguagePack.download(names: ["python"])
print(result)

Zig

Download a single language parser and verify count

Zig

const std = @import("std");
const tree_sitter_language_pack = @import("tree_sitter_language_pack");

pub fn main() !void {
    const result = try tree_sitter_language_pack.download("[\"python\"]");
    std.debug.print("{any}\n", .{result});

}

Kotlin (Android)

prefetch([‘python’]) downloads and loads parser

Kotlin (Android)

import io.xberg.tslp.android.*

fun main() {
    TreeSitterLanguagePack.prefetch(listOf("python"))
}

WebAssembly

prefetch([‘python’]) downloads and loads parser

WebAssembly

import { prefetch } from "@xberg-io/tree-sitter-language-pack-wasm";
function main() {
  const result = prefetch(["python"]);
}

void main();

Rust

Download a single language parser and verify count

Rust

use tree_sitter_language_pack::download;

fn main() {
    let names_json: serde_json::Value = serde_json::from_str(r#"["python"]"#).unwrap();
    let names = serde_json::from_value::<Vec<String>>(names_json).unwrap();
    let names_refs: Vec<&str> = names.iter().map(String::as_str).collect();
    let result = download(&names_refs);
    println!("{:?}", result);
}

All 371 languages

CLI

ts-pack download --all

Python

from tree_sitter_language_pack import download_all

download_all()

Node.js

import { downloadAll } from "@xberg-io/tree-sitter-language-pack";

downloadAll();

Rust

use tree_sitter_language_pack::download_all;

download_all()?;

By language group

Group names are manifest data, not a compile-time constant. The published manifest currently defines exactly one group, "all" — there is no web, data, or systems group, and passing one fails. Enumerate the real names with manifest_groups() before calling download_group().

Python

from tree_sitter_language_pack import download_group, manifest_groups

for group in manifest_groups():
    print(group)  # currently prints just: all

download_group("all")

Rust

use tree_sitter_language_pack::{download_group, manifest_groups};

let group = manifest_groups()?
    .into_iter()
    .next()
    .expect("manifest defines no groups");
let count = download_group(&group)?;
println!("{count} languages available");

Docker and CI

Pre-download parsers during your build to avoid runtime network calls:

Dockerfile

FROM python:3.12-slim
RUN pip install tree-sitter-language-pack
# Pre-download at build time — no network needed at runtime
RUN python -c "from tree_sitter_language_pack import download_all; download_all()"

GitHub Actions

- name: Install and pre-download parsers
  run: |
    pip install tree-sitter-language-pack
    python -c "from tree_sitter_language_pack import download; download(['python', 'javascript', 'rust'])"

Configuration file

Declare which languages your project needs in a language-pack.toml:

language-pack.toml

languages = ["python", "javascript", "rust", "go"]
# groups = ["all"]   # only names returned by manifest_groups() are accepted
# cache_dir = "/tmp/parsers"

Then download everything declared in the config:

CLI

# Reads language-pack.toml automatically
ts-pack download

Python

from tree_sitter_language_pack import init

# Reads language-pack.toml from current directory
init()

Cache location

Parsers cache to <cache>/tree-sitter-language-pack/v{version}/libs — where <cache> is ~/.cache on Linux, ~/Library/Caches on macOS, and %LOCALAPPDATA% on Windows. Override with cache_dir in language-pack.toml or the programmatic API. See Download Model for full details.

---

3. Parse Code

Run the parser over a source string. process() parses the source and returns the result; if the language is not cached yet it is downloaded on this first call.

CLI

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

Python

Parse a Python function definition and assert node type

Python

from tree_sitter_language_pack import process

def main() -> None:
    source = "def hello(): pass"
    config = {"language": "python"}
    result = process(source, config)
    print(result)

main()

Node.js

Parse a Python function definition and assert node type

TypeScript

import { process } from "@xberg-io/tree-sitter-language-pack";
function main() {
  const result = process("def hello(): pass", { language: "python" });
  console.log(result);
}

void main();

Ruby

Parse a Python function definition and assert node type

Ruby

require "tree_sitter_language_pack"
result = TreeSitterLanguagePack.process('def hello(): pass', { 'language' => 'python' })
puts result.inspect

PHP

Parse a Python function definition and assert node type

PHP

<?php

declare(strict_types=1);

require_once __DIR__ . '/vendor/autoload.php';

use Tree\Sitter\Language\Pack\TreeSitterLanguagePack;
use Tree\Sitter\Language\Pack\Language;
use Tree\Sitter\Language\Pack\ProcessConfig;
use Tree\Sitter\Language\Pack\Tree;
$config = \Tree\Sitter\Language\Pack\ProcessConfig::from_json(json_encode(["language" => "python"]));
$result = TreeSitterLanguagePack::process("def hello(): pass", $config);
var_dump($result);

Go

Parse a Python function definition and assert node type

Go

package main

import (
  "fmt"
  tspack "github.com/xberg-io/tree-sitter-language-pack/packages/go"
)

func main() {
  config := tspack.ProcessConfig{
    Language: `python`,
  }
  result, err := tspack.Process(`def hello(): pass`, config)
  if err != nil {
    panic(err)
  }
  fmt.Printf("%+v\n", result)
}

Java

Parse a Python function definition and assert node type

Java

import io.xberg.treesitterlanguagepack.*;

public final class Example {
    public static void main(String[] args) throws Exception {
        var configJson = "{\"language\":\"python\"}";
        var config = JsonUtil.fromJson(configJson, ProcessConfig.class);
        var result = TreeSitterLanguagePack.process("def hello(): pass", config);
        System.out.println(result);
    }
}

C#

Parse a Python function definition and assert node type

C#

using System;
using TreeSitterLanguagePack;

var result = TreeSitterLanguagePackConverter.Process("def hello(): pass", new ProcessConfig { Language = "python" });
Console.WriteLine(result);

Elixir

Parse a Python function definition and assert node type

Elixir

config_value = %TreeSitterLanguagePack.ProcessConfig{language: "python"}
result = TreeSitterLanguagePack.process("def hello(): pass", config_value)
IO.inspect(result)

Dart

Parse a Python function definition and assert node type

Dart

import 'dart:io';
import 'package:tree_sitter_language_pack/tree_sitter_language_pack.dart';
import 'package:tree_sitter_language_pack/src/tree_sitter_language_pack_bridge_generated/frb_generated.dart' show RustLib;
Future<void> main() async {
  await RustLib.init();
  try {
    final config = await createProcessConfigFromJson(json: '{"language":"python"}');
    final result = await TreeSitterLanguagePackBridge.process('def hello(): pass', config: config);
    stdout.writeln(result);
  } finally {
    RustLib.dispose();
  }
}

Swift

Parse a Python function definition and assert node type

Swift

import TreeSitterLanguagePack

let configObj = try TreeSitterLanguagePack.processConfigFromJson("{\"language\":\"python\"}")
let result = try TreeSitterLanguagePack.process(source: "def hello(): pass", config: configObj)
print(result)

Zig

Parse a Python function definition and assert node type

Zig

const std = @import("std");
const tree_sitter_language_pack = @import("tree_sitter_language_pack");

pub fn main() !void {
    const _result_json = try tree_sitter_language_pack.process("def hello(): pass", "{\"language\":\"python\"}");
    defer std.heap.c_allocator.free(_result_json);
    std.debug.print("{s}\n", .{_result_json});

}

Kotlin (Android)

Parse a Python function definition and assert node type

Kotlin (Android)

import io.xberg.tslp.android.*
import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper

fun main() {
    val mapper = jacksonObjectMapper()
    val config = mapper.readValue("{\"language\":\"python\"}", ProcessConfig::class.java)
    val result = TreeSitterLanguagePack.process("def hello(): pass", config)
    println(result)
}

WebAssembly

Parse a Python function definition and assert node type

WebAssembly

import { process } from "@xberg-io/tree-sitter-language-pack-wasm";
function main() {
  const result = process("def hello(): pass", { language: "python" });
  console.log(result);
}

void main();

Rust

Parse a Python function definition and assert node type

Rust

use tree_sitter_language_pack::process;

fn main() {
    let source = r#"def hello(): pass"#;
    let config_json: serde_json::Value = serde_json::from_str(r#"{"language":"python"}"#).unwrap();
    let config = serde_json::from_value(config_json).unwrap();
    let result = process(source, &config);
    println!("{:?}", result);
}

---

4. Extract Code Intelligence

Go beyond the raw syntax tree. Extract functions, classes, imports, docstrings, and more with process.

CLI

CLI

# Parse and show S-expression
ts-pack parse main.py --language python

# Parse as JSON
echo "fn main() {}" | ts-pack parse - --language rust --format json

# Full code intelligence
ts-pack process src/app.py --language python --all

# Structure + imports only
ts-pack process src/app.py --structure --imports

Python

Intel: process with all features enabled

Python

from tree_sitter_language_pack import process

def main() -> None:
    source = "# A comment\ndef greet(name):\n    \"\"\"Say hello.\"\"\"\n    return f'Hi {name}'\n\nimport os\n"
    config = {"language": "python"}
    result = process(source, config)
    print(result)

main()

Node.js

Intel: process with all features enabled

TypeScript

import { process } from "@xberg-io/tree-sitter-language-pack";
function main() {
  const result = process("# A comment\ndef greet(name):\n    \"\"\"Say hello.\"\"\"\n    return f'Hi {name}'\n\nimport os\n", { language: "python" });
  console.log(result);
}

void main();

Ruby

Intel: process with all features enabled

Ruby

require "tree_sitter_language_pack"
result = TreeSitterLanguagePack.process("\# A comment\ndef greet(name):\n    \"\"\"Say hello.\"\"\"\n    return f'Hi {name}'\n\nimport os\n", { 'language' => 'python' })
puts result.inspect

PHP

Intel: process with all features enabled

PHP

<?php

declare(strict_types=1);

require_once __DIR__ . '/vendor/autoload.php';

use Tree\Sitter\Language\Pack\TreeSitterLanguagePack;
use Tree\Sitter\Language\Pack\Language;
use Tree\Sitter\Language\Pack\ProcessConfig;
use Tree\Sitter\Language\Pack\Tree;
$config = \Tree\Sitter\Language\Pack\ProcessConfig::from_json(json_encode(["language" => "python"]));
$result = TreeSitterLanguagePack::process("# A comment\ndef greet(name):\n    \"\"\"Say hello.\"\"\"\n    return f'Hi {name}'\n\nimport os\n", $config);
var_dump($result);

Go

Intel: process with all features enabled

Go

package main

import (
  "fmt"
  tspack "github.com/xberg-io/tree-sitter-language-pack/packages/go"
)

func main() {
  config := tspack.ProcessConfig{
    Language: `python`,
  }
  result, err := tspack.Process(`# A comment
def greet(name):
    """Say hello."""
    return f'Hi {name}'

import os
`, config)
  if err != nil {
    panic(err)
  }
  fmt.Printf("%+v\n", result)
}

Java

Intel: process with all features enabled

Java

import io.xberg.treesitterlanguagepack.*;

public final class Example {
    public static void main(String[] args) throws Exception {
        var configJson = "{\"language\":\"python\"}";
        var config = JsonUtil.fromJson(configJson, ProcessConfig.class);
        var result = TreeSitterLanguagePack.process("# A comment\ndef greet(name):\n    \"\"\"Say hello.\"\"\"\n    return f'Hi {name}'\n\nimport os\n", config);
        System.out.println(result);
    }
}

C#

Intel: process with all features enabled

C#

using System;
using TreeSitterLanguagePack;

var result = TreeSitterLanguagePackConverter.Process("# A comment\ndef greet(name):\n    \"\"\"Say hello.\"\"\"\n    return f'Hi {name}'\n\nimport os\n", new ProcessConfig { Language = "python" });
Console.WriteLine(result);

Elixir

Intel: process with all features enabled

Elixir

config_value = %TreeSitterLanguagePack.ProcessConfig{language: "python"}
result = TreeSitterLanguagePack.process("\# A comment\ndef greet(name):\n    \"\"\"Say hello.\"\"\"\n    return f'Hi {name}'\n\nimport os\n", config_value)
IO.inspect(result)

Dart

Intel: process with all features enabled

Dart

import 'dart:io';
import 'package:tree_sitter_language_pack/tree_sitter_language_pack.dart';
import 'package:tree_sitter_language_pack/src/tree_sitter_language_pack_bridge_generated/frb_generated.dart' show RustLib;
Future<void> main() async {
  await RustLib.init();
  try {
    final config = await createProcessConfigFromJson(json: '{"language":"python"}');
    final result = await TreeSitterLanguagePackBridge.process('# A comment\ndef greet(name):\n    """Say hello."""\n    return f\'Hi {name}\'\n\nimport os\n', config: config);
    stdout.writeln(result);
  } finally {
    RustLib.dispose();
  }
}

Swift

Intel: process with all features enabled

Swift

import TreeSitterLanguagePack

let configObj = try TreeSitterLanguagePack.processConfigFromJson("{\"language\":\"python\"}")
let result = try TreeSitterLanguagePack.process(source: "# A comment\ndef greet(name):\n    \"\"\"Say hello.\"\"\"\n    return f'Hi {name}'\n\nimport os\n", config: configObj)
print(result)

Zig

Intel: process with all features enabled

Zig

const std = @import("std");
const tree_sitter_language_pack = @import("tree_sitter_language_pack");

pub fn main() !void {
    const _result_json = try tree_sitter_language_pack.process("# A comment\ndef greet(name):\n    \"\"\"Say hello.\"\"\"\n    return f'Hi {name}'\n\nimport os\n", "{\"language\":\"python\"}");
    defer std.heap.c_allocator.free(_result_json);
    std.debug.print("{s}\n", .{_result_json});

}

Kotlin (Android)

Intel: process with all features enabled

Kotlin (Android)

import io.xberg.tslp.android.*
import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper

fun main() {
    val mapper = jacksonObjectMapper()
    val config = mapper.readValue("{\"language\":\"python\"}", ProcessConfig::class.java)
    val result = TreeSitterLanguagePack.process("# A comment\ndef greet(name):\n    \"\"\"Say hello.\"\"\"\n    return f'Hi {name}'\n\nimport os\n", config)
    println(result)
}

WebAssembly

Intel: process with all features enabled

WebAssembly

import { process } from "@xberg-io/tree-sitter-language-pack-wasm";
function main() {
  const result = process("# A comment\ndef greet(name):\n    \"\"\"Say hello.\"\"\"\n    return f'Hi {name}'\n\nimport os\n", { language: "python" });
  console.log(result);
}

void main();

Rust

Intel: process with all features enabled

Rust

use tree_sitter_language_pack::process;

fn main() {
    let source = r#"# A comment
def greet(name):
    """Say hello."""
    return f'Hi {name}'

import os
"#;
    let config_json: serde_json::Value = serde_json::from_str(r#"{"language":"python"}"#).unwrap();
    let config = serde_json::from_value(config_json).unwrap();
    let result = process(source, &config);
    println!("{:?}", result);
}

---

5. Inspect Query Sources

process() covers the built-in intelligence fields. There is no public extract() helper for arbitrary query execution. For custom analysis, fetch bundled query source with helpers such as get_tags_query(), then run tree-sitter query APIs yourself or walk the AST manually.

Python

from tree_sitter_language_pack import get_tags_query

tags_query = get_tags_query("python")
if tags_query is not None:
    print(tags_query.splitlines()[0])

Rust

use tree_sitter_language_pack::{get_parser, get_tags_query};

let query_source = get_tags_query("rust");
let mut parser = get_parser("rust")?;
let tree = parser.parse("fn main() {}").ok_or("failed to parse")?;
println!("{}", tree.root_node().kind());

---

6. Chunk for LLMs

Split code at natural boundaries so language models receive coherent, complete units which is ideal for embedding pipelines and context windows.

Python

from tree_sitter_language_pack import process, ProcessConfig

with open("large_module.py") as f:
    source = f.read()

config = ProcessConfig(
    language="python",
    chunk_max_size=1500,  # max bytes per chunk
    structure=True,
)
result = process(source, config)

for i, chunk in enumerate(result.chunks):
    print(f"Chunk {i}: lines {chunk.start_line}-{chunk.end_line} "
          f"({chunk.end_byte - chunk.start_byte} bytes)")

Node.js

import { process } from "@xberg-io/tree-sitter-language-pack";
import { readFileSync } from "fs";

const source = readFileSync("large_module.ts", "utf8");

const result = process(source, {
  language: "typescript",
  chunkMaxSize: 1500,
  structure: true,
});

result.chunks.forEach((chunk, i) => {
  console.log(`Chunk ${i}: lines ${chunk.startLine}-${chunk.endLine} (${chunk.endByte - chunk.startByte} bytes)`);
});

CLI

# Chunk a file for LLM ingestion
ts-pack process large_module.py --chunk-size 1500 \
  | jq '.chunks[] | {start: .start_line, end: .end_line, bytes: (.end_byte - .start_byte)}'

---

You now have the full workflow. You can now install, download, parse, extract intelligence, inspect query sources, and chunk for LLMs. Go further with the following guides:

• Parsing guide — syntax trees, error handling, and incremental parsing
• Configuration — language-pack.toml and advanced options
• API Reference — full API docs for every binding