Language services

Active contributors: osiewicz, smitbarmase, SomeoneToIgnore, Veykril, probably-neb

Purpose

The language services layer maps file paths to syntax trees, indentation rules, embedded language regions, and language-server adapters. It is what makes Zed know that foo.rs is Rust, that foo.html may contain JavaScript, and that bar.py should boot pyright.

Crates

Crate	Role
crates/language	The Buffer, Language, LanguageRegistry, syntax tree wiring
crates/language_core	Lower-level primitives shared by language and remote/headless
crates/language_extension	Plumbing for extension-provided languages
crates/languages	First-party language definitions and configuration
crates/grammars	Tree-sitter grammar bundles
crates/syntax_theme	Syntax highlighting themes
crates/language_tools	In-app log/diagnostic UI for language servers
crates/language_selector	"Pick language" picker
crates/language_onboarding	First-run language setup hints
crates/language_model_core, crates/language_model, crates/language_models, crates/language_models_cloud	LLM provider abstractions (separate from text-language)

Two unrelated "language" namespaces share the prefix: text languages (Rust/Python/HTML/...) and language models (Anthropic/OpenAI/...). The text-language crates are what this page covers.

Key abstractions

Type	File	Description
Language	crates/language/src/language.rs	One language definition (grammar, config, adapter list)
LanguageRegistry	crates/language/src/language_registry.rs	Global registry; matches paths to languages
Buffer	crates/language/src/buffer.rs	Text + syntax tree + diagnostics
LanguageConfig	crates/language/src/language.rs	Brackets, comment delimiters, line endings, etc.
LspAdapter	crates/language/src/lsp_adapter.rs (and per-language)	Per-language LSP wrapper (install + initialize + transform)
LanguageMatcher	crates/language/src/language.rs	File-extension / shebang / first-line matching rules
Tree-sitter Grammar	crates/grammars	Compiled grammar bundles

How it works

graph TD
    R[LanguageRegistry] --> L1[Language: rust]
    R --> L2[Language: typescript]
    R --> L3[Language: html]
    L1 --> A1[LspAdapter: rust-analyzer]
    L2 --> A2[LspAdapter: typescript-language-server]
    L3 --> A3[LspAdapter: vscode-html-language-server]
    L1 --> G1[Grammar: tree-sitter-rust]
    L2 --> G2[Grammar: tree-sitter-typescript]
    L3 --> G3[Grammar: tree-sitter-html]
    EXT[Extensions] -.->|register| R
    BUF[Buffer] -->|uses| L1

Language detection

A LanguageMatcher checks:

1. File path / extension.
2. Shebang line.
3. First-line content (e.g. #!/usr/bin/env ruby).
4. Explicit user override in crates/language_selector.

The first match wins. The user can override per-buffer through the language selector palette.

Embedded languages

Languages can declare injections via Tree-sitter: e.g. JavaScript inside HTML <script>, SQL inside Python f-strings. The buffer keeps a tree per nested language and dispatches highlighting and LSP queries to the appropriate inner language.

First-party vs extension languages

Built-in languages live in crates/languages (e.g. Rust, Go, Python, JavaScript). Community languages live in WASM extensions and register themselves through crates/extension_host.

Integration points

• Used by: crates/editor (for highlighting, brackets, indent), crates/project (for LSP wiring), crates/multi_buffer (for syntax-aware excerpts).
• Calls: crates/lsp (to start language servers), crates/grammars (to load tree-sitter grammars), crates/extension_host (for extension-provided languages).

Entry points for modification

• Adding a built-in language — drop a file in crates/languages/src/, register in crates/languages/src/languages.rs, add the grammar.
• Adding an extension language — write a Zed extension; see Extensions.
• New tree-sitter grammar — add to crates/grammars (or via extension).
• Adjusting embedded-language injection — the relevant Language's injections.scm query.

Related pages

• LSP — what language adapters drive
• Extensions — third-party language registration
• Editor — consumer of syntax info