helix-editor/helix
71.5
Strong · 14 November 2026
87.7k
lines of production code
Rust
primary language
6
measurements over time
What this system is
Features
Add Agda syntax highlighting support
Users can now see syntax-highlighted Agda code in the editor. This change adds a new query file for Agda that defines highlighting rules for punctuation, constants, pragmas, comments, imports, types, variables, functions, data constructors, and keywords.
runtime/queries/agda · high confidence
Add AppStream metadata and desktop integration files
The contrib directory now includes Helix.appdata.xml, Helix.desktop, and hx\_launcher.sh to improve Linux desktop integration. The AppStream metadata file provides structured release history, screenshots, and content ratings for software centers, while the desktop entry file registers Helix as a text editor with multi-language support and specific MIME type associations. A launcher script is also added to set the runtime path, and a symlink points to the themes directory.
contrib · high confidence
Add Beancount syntax highlighting and folding support
Users can now edit Beancount files with proper syntax highlighting and code folding. The new runtime queries define visual styles for Beancount-specific elements such as accounts, amounts, currencies, tags, links, and directives (like open, close, commodity, and include), as well as standard components like dates, transactions, and comments. Additionally, transactions and sections are configured to be foldable, improving readability for large ledger files.
runtime/queries/beancount, runtime/queries/teal · high confidence
Add Caddyfile syntax highlighting and editing support
Added syntax highlighting, indentation, injection, local scope, and text object definitions for the Caddyfile configuration format. This enables proper visual styling of directives, matchers, and literals, as well as improved editing capabilities like block selection and indentation handling within Caddyfile buffers.
runtime/queries/caddyfile · high confidence
Add Clojure language support with syntax highlighting, indentation, and navigation queries
Users can now edit Clojure files with proper syntax highlighting, automatic indentation, and code navigation features. The new query files in runtime/queries/clojure define how Clojure code is rendered and understood: highlights distinguish keywords, strings, numbers, booleans, symbols, functions, macros, and built-ins; indents handle list, vector, map, and set structures with special rules for def-like forms and bindings; injections enable regex highlighting inside string literals; rainbows color-matching brackets and scopes; tags identify definitions for functions, macros, interfaces, records, and namespaces; and textobjects allow selecting function bodies, class definitions, test blocks, parameters, and collection entries.
(repo-wide) · high confidence
Add Concerto language support for Helix editor
This change adds runtime query files for the Concerto modeling language in the Helix editor, enabling syntax highlighting, indentation, local scope tracking, and text object selection. Users can now edit Concerto files with proper visual feedback and navigation features within Helix.
runtime/queries/concerto · high confidence
Add Earthfile language configuration
Added syntax highlighting, indentation, injection, and text object queries for the Earthfile language, enabling proper editing support for Earthfiles in the editor.
runtime/queries/earthfile · high confidence
Add Emacs Lisp syntax highlighting and symbol navigation
Added support for Emacs Lisp (Elisp) by introducing new query files for syntax highlighting, local variable scoping, and tag generation. Users can now see Elisp code highlighted with proper keywords, strings, comments, and constants, while IDE features like 'go to definition' and 'find references' will correctly identify function definitions, macro definitions, and variable bindings within lambda, let, and let\* forms.
runtime/queries/elisp · high confidence
Add F\# syntax highlighting and scope queries
This change introduces the initial F\# language support by adding query files for syntax highlighting, local variable scoping, bracket rainbowing, and injection rules. Users will now see F\# code properly highlighted (identifying types, functions, parameters, and literals) and have accurate navigation support for local definitions and references within the editor.
runtime/queries/fsharp · high confidence
Add Fortran syntax highlighting, folding, and indentation
New runtime query files for the Fortran language provide syntax highlighting, code folding, and indentation support. The highlights query defines keywords, operators, comments, and specific Fortran constructs like modules and subroutines. The folds query enables folding for control structures (if, do, where), type definitions, and procedures. The indents query configures automatic indentation for modules, programs, subroutines, functions, and control blocks, while injections query handles comment injection.
runtime/queries/fortran, runtime/queries/koto · high confidence
Add GLSL syntax highlighting and query support
This change introduces initial query files for GLSL (OpenGL Shading Language) in the \runtime/queries/glsl\ directory. It enables syntax highlighting for GLSL-specific keywords (such as \uniform\, \layout\, \precision\, and built-in variables like \gl\\\), defines text objects, locals, tags, and indentation rules by inheriting from C, and sets up injection for preprocessor arguments. This allows editors using this runtime to correctly parse and highlight GLSL code.
runtime/queries/glsl · high confidence
Add GNU gettext PO grammar support
Added syntax highlighting and text object definitions for GNU gettext PO files. Users will now see syntax highlighting for PO-specific elements like msgctxt, msgid, msgstr, and comments, as well as the ability to select text objects within these files.
runtime/queries/po · high confidence
Add GitLab CI language support with syntax highlighting and injection queries
Added a new \gitlab-ci\ language definition (specialized from \yaml\) that provides syntax highlighting for GitLab CI-specific keywords (such as \variables\, \stages\, \default\, \include\, \workflow\) and builtin stages (\.pre\, \build\, \test\, \deploy\, \.post\). It also enables syntax injection for bash scripts in job execution fields (\script\, \before\_script\, \after\_script\, \pre\_get\_sources\script\, \command\, \entrypoint\) and for regex patterns in \coverage\ and \spec.inputs.\.regex\ values.
runtime/queries/gitlab-ci · high confidence
Add Graphviz Dot language support
Users can now get syntax highlighting and HTML injection support for Graphviz Dot files. This change introduces new highlight queries that define styling for identifiers, keywords, strings, numbers, operators, delimiters, brackets, subgraphs, attributes, comments, and preprocessor directives, along with an injection query to highlight HTML content within Dot files.
runtime/queries/dot · high confidence
Add HCL language support with syntax queries
Adds support for the HCL language by introducing new query files (folds, highlights, indents, injections, rainbows, and textobjects) in the runtime/queries/hcl directory. This enables syntax highlighting, code folding, indentation, rainbow bracket matching, and text object selection for HCL files.
runtime/queries/hcl · high confidence
Add HEEx syntax highlighting, injection, and textobject queries
This change introduces the runtime query files for HEEx (HTML + Elixir) templates, enabling proper syntax highlighting, code injection, and text object selection. The highlights.scm file defines how HEEx-specific elements like delimiters, directives, slots, and components are visually distinguished, while injections.scm ensures that embedded Elixir code within HEEx tags is correctly parsed and highlighted as Elixir. Additionally, textobjects.scm allows users to select HEEx comments as text objects, improving navigation and editing capabilities for HEEx files.
runtime/queries/heex · high confidence
Add Java .properties file support
This change introduces support for Java .properties files by adding syntax highlighting, text objects, local variable definitions, and injection queries. Users will now see proper syntax highlighting for keys, values, comments, and special characters like escapes and substitutions, as well as the ability to select properties and comments as text objects.
runtime/queries/properties · high confidence
Add LSP-style snippet support to Helix core
Helix now supports LSP/VSCode-style snippets, allowing users to insert and navigate through structured code templates. This change introduces a new snippet system in \helix-core\ that includes a parser for snippet syntax (tabstops, placeholders, choices, variables, and text transforms), an elaboration engine to resolve tabstop indices and parent relationships, and a renderer that applies snippets to the document while tracking active tabstops for cursor navigation. Users can now use snippets to speed up repetitive coding tasks, with support for placeholder text, choice lists, and variable transformations.
helix-core/src/snippets · high confidence
Add LaTeX syntax highlighting, folding, and indentation support
New query files have been added for the LaTeX language, enabling syntax highlighting, code folding, indentation, and text object selection. Users will now see LaTeX commands, environments, comments, and math blocks highlighted according to their semantic role, while sectioning commands and environments can be folded. Indentation rules are applied to environments and groups, and text objects allow for easier navigation of commands and structural elements.
runtime/queries/latex, runtime/queries/prolog · high confidence
Add Lean syntax highlighting and folding queries
Added new tree-sitter query files for the Lean language to provide syntax highlighting, code folding, and local scope detection. The highlights query defines keywords, operators, types, functions, and booleans, while the folds query enables folding for namespaces, sections, definitions, and data structures. Injections are configured to treat comments as Markdown, and locals are scoped to modules, namespaces, and sections.
runtime/queries/lean, runtime/queries/supercollider · high confidence
Add Luau language support with syntax highlighting, indentation, and text objects
This change introduces initial support for the Luau programming language by adding new query files (\highlights.scm\, \indents.scm\, \injections.scm\, \locals.scm\, \textobjects.scm\) in the \runtime/queries/luau\ directory. Users will now see proper syntax highlighting for Luau keywords, types, and string interpolations, along with correct indentation behavior for control structures and function definitions. The update also enables text object selection for functions and parameters, and injects Lua pattern matching syntax highlighting within specific string method calls like \string.match\ and \string.format\.
runtime/queries/cairo, runtime/queries/luau, runtime/queries/ponylang · high confidence
Add MSBuild language support with XML-based syntax highlighting
This change introduces initial support for the MSBuild language by adding syntax highlighting, indentation, and injection queries. These new files inherit their behavior from the existing XML grammar, enabling basic text editing features for MSBuild project files.
runtime/queries/msbuild · high confidence
Add MoonBit language support
This change adds support for the MoonBit programming language by introducing new query files in the runtime/queries/moonbit directory. These files define syntax highlighting, indentation rules, local variable scopes, tag definitions for navigation, and text objects for code selection, enabling proper language integration for MoonBit source files.
(repo-wide) · high confidence
Add MoonBit language support
This change adds support for the MoonBit programming language by introducing new query files in the runtime/queries/moonbit directory. These files define syntax highlighting, indentation rules, local variable scopes, tag definitions for navigation, and text objects for code selection, enabling proper language integration for MoonBit source files.
runtime/queries/moonbit · high confidence
Add Nushell syntax queries for folding, highlighting, indentation, and text objects
This change introduces the initial set of Tree-sitter query files for the Nushell language, enabling core editing features in compatible editors. The new \runtime/queries/nu/\ directory includes \highlights.scm\ for syntax coloring (keywords, literals, operators, flags), \folds.scm\ to define collapsible regions like blocks and records, \indents.scm\ for correct indentation of expressions and containers, \injections.scm\ to highlight embedded content such as regexes, nested Nushell scripts, and jq commands, and \textobjects.scm\ to allow selection of functions, comments, and parameters.
runtime/queries/nu · high confidence
Add PHP syntax highlighting, scope, and tag queries
This change introduces the initial set of Tree-sitter query files for PHP, enabling syntax highlighting, local variable scoping, and symbol tagging. The \highlights.scm\ file defines scopes for PHP tags, variables, constants, types, functions, and keywords, while \locals.scm\ establishes scope boundaries for functions, methods, and statements, and identifies variable definitions and references. Additionally, \tags.scm\ provides definitions and references for namespaces, classes, interfaces, traits, fields, and functions, and \injections.scm\ handles syntax injection for heredocs and nowdocs.
runtime/queries/php-only · high confidence
Add PowerShell syntax highlighting and rainbow brackets
Users now get syntax highlighting for PowerShell scripts, including keywords, operators, literals, and functions, along with rainbow bracket support for improved code readability.
runtime/queries/powershell · high confidence
Add Rescript syntax highlighting, text objects, and injection queries
This change introduces the initial language support for Rescript by adding syntax highlighting, text object definitions, and injection queries. The new \highlights.scm\ file defines how Rescript code is visually categorized, including operators, punctuation, identifiers, types, strings, and keywords. The \textobjects.scm\ file enables navigation and selection of code structures such as modules, functions, parameters, and comments. Additionally, \injections.scm\ allows for syntax highlighting of embedded content within Rescript extension expressions, specifically supporting regex (\%re\), JavaScript (\%raw\), and GraphQL (\%graphql\, \%relay\) strings.
(repo-wide) · high confidence
Add Scala syntax highlighting and language support queries
Adds the initial set of tree-sitter query files for Scala, enabling syntax highlighting, indentation, local variable tracking, tag generation, text objects, and SQL string injection. Users will now see Scala code properly highlighted with distinct styles for types, functions, and keywords; indentation will adjust correctly for blocks, classes, and control structures; and features like 'go to definition' and text-object selection (e.g., selecting a function body) will work for Scala sources.
runtime/queries/jq, runtime/queries/scala · high confidence
Add Swift syntax highlighting, indentation, and text object queries
This change introduces the initial set of Tree-sitter query files for Swift, enabling syntax highlighting, proper indentation, rainbow bracket matching, and text object selection (e.g., selecting function bodies or classes) in Swift source files. The \highlights.scm\ file defines color rules for keywords, types, operators, and literals, including support for modern Swift features like \async\/\await\ and \any\/\some\ types. The \indents.scm\ file provides indentation rules for control flow, declarations, and expressions. Additional files (\locals.scm\, \tags.scm\, \textobjects.scm\, \rainbows.scm\, \injections.scm\) add support for local variable tracking, symbol tagging, text object motions, rainbow delimiters, and regex injection in string literals.
(repo-wide) · high confidence
Add Twig syntax highlighting and HTML injection queries
Added syntax highlighting and injection queries for the Twig template language. The new \highlights.scm\ file defines token types for Twig-specific constructs such as filters, functions, variables, strings, operators, and delimiters (e.g., \{{ }}\, \{% %}\). The \injections.scm\ file configures the content within Twig templates to be injected as HTML, enabling proper syntax highlighting for embedded HTML code within Twig files.
runtime/queries/twig · high confidence
Add TypeScript-specific syntax highlighting and text object queries
New query files (highlights, indents, locals, tags, textobjects) are added for TypeScript, providing language-specific syntax highlighting rules, indentation logic, local scope definitions, tag definitions for navigation, and text objects for selecting class and enum bodies. This improves the accuracy of code highlighting and editing commands for TypeScript files compared to generic ECMAScript queries.
_runtime/queries/\typescript · high confidence
Add Typst syntax highlighting, tags, and text objects
This change introduces the initial set of Tree-sitter queries for the Typst language, enabling syntax highlighting, code navigation, and text object selection. The \highlights.scm\ file defines scopes for keywords, operators, values, functions, and markup elements (such as headings, lists, and raw blocks). The \tags.scm\ file maps headings and labels to definition scopes for navigation. Additionally, \textobjects.scm\ provides text objects for functions, parameters, entries, and comments, while \injections.scm\ handles syntax highlighting for code blocks and comments embedded within Typst documents.
runtime/queries/typst · high confidence
Add Unison syntax highlighting and code navigation queries
This change introduces the initial set of tree-sitter query files for the Unison language, enabling syntax highlighting, indentation, and code navigation features. The new files define how Unison syntax elements are highlighted (e.g., keywords, types, comments), how indentation is calculated for terms and patterns, and how text objects (functions, classes, comments) are identified for selection. It also adds support for rainbow delimiters and tag definitions for functions and types, allowing users to navigate to definitions and use improved editing commands within Unison code.
runtime/queries/unison · high confidence
Add YAML syntax highlighting for Helm templates
Helm template files now receive proper YAML syntax highlighting. The new injection rules detect text content within Helm templates and treat it as YAML, ensuring that code editors correctly highlight YAML structures embedded in Go template files.
runtime/queries/helm · high confidence
Add basic syntax highlighting and indentation for Quarto files
Users can now get basic syntax highlighting, indentation, and injection support for Quarto documents. These new query files inherit their behavior from Markdown, providing immediate out-of-the-box editing assistance for .qmd files without requiring additional configuration.
runtime/queries/quarto · high confidence
Add initial syntax highlighting and code injection support for BitBake
Users can now get syntax highlighting and embedded language injection for BitBake files. The new \runtime/queries/bitbake/highlights.scm\ file defines highlighting rules for variables, operators, functions, and keywords specific to the BitBake build system. Additionally, \runtime/queries/bitbake/injections.scm\ enables syntax highlighting for embedded Python code within Python function definitions and for embedded Bash code within standard function definitions.
runtime/queries/bitbake, runtime/queries/xwiki · high confidence
Add language support for Cap’n Proto format
Added syntax highlighting, folding, indentation, and local variable tracking for Cap’n Proto files. This enables proper code navigation and visual structure for .capnp schema definitions within the editor.
runtime/queries/capnp · high confidence
Add shell completion scripts for Bash, Zsh, Fish, Nushell, and Elvish
Users can now enable command-line autocompletion for the \hx\ editor in Bash, Zsh, Fish, Nushell, and Elvish shells. These new scripts in \contrib/completion\ provide context-aware suggestions for flags (such as \--config\, \--log\, \--strict\, \--vsplit\, \--hsplit\) and dynamic completions for \--health\ (listing available languages) and \--grammar\ (fetch/build actions), significantly improving the CLI experience across supported shells.
contrib/completion · high confidence
Add standalone syntax highlighting and editing support for Justfiles
This change introduces a complete set of syntax queries for the \just\ language, enabling standalone support in the editor. Users will now get proper syntax highlighting for keywords, variables, functions, and operators, as well as code folding for recipes and strings. The update also adds auto-indentation rules, local variable scoping for navigation, tag definitions for jumping to aliases and recipes, and text objects for selecting functions and parameters. Additionally, it supports nested language injection, allowing bash or PowerShell syntax highlighting within recipe bodies and external commands, including detection of the shell via the \set shell\ directive.
runtime/queries/just · high confidence
Add support for incrementing dates, times, and integers
Users can now increment or decrement date, time, and integer values directly within the editor. The new \helix-core/src/increment\ module provides logic to handle various date and time formats (such as \YYYY-MM-DD\, \HH:MM\, and others) as well as integers in decimal, hexadecimal, octal, and binary bases, including support for underscores as digit separators and preservation of case in hexadecimal literals.
helix-core/src/increment · high confidence
Add syntax highlighting and Markdown injection for Markdoc
Users can now see Markdoc files highlighted in the editor with specific syntax rules for tags, attributes, variables, functions, and literals. Additionally, Markdown content embedded within Markdoc files is automatically injected and highlighted as standard Markdown.
runtime/queries/markdoc · high confidence
Add syntax highlighting and code injection for Djot documents
Users can now get syntax highlighting and nested language injection for Djot files. The new \runtime/queries/djot/highlights.scm\ file defines visual styles for headings, lists, tables, quotes, code blocks, and inline formatting, while \runtime/queries/djot/injections.scm\ enables syntax highlighting for code blocks, raw blocks, and LaTeX math content embedded within Djot documents.
runtime/queries/djot · high confidence
Add syntax highlighting and code injection for Literate Haskell
Users can now get proper syntax highlighting and code injection for Literate Haskell files. The new query files define highlighting rules for bird-track markers, LaTeX delimiters, and Markdown delimiters, while injecting the Haskell grammar into code blocks within these formats to ensure code is highlighted correctly.
runtime/queries/haskell-literate · high confidence
Add syntax highlighting and code injection for mise configuration files
Users editing mise configuration files (mise.toml) will now see improved syntax support, including proper indentation and text object selection inherited from TOML. Additionally, bash code injection is enabled for task definitions, allowing syntax highlighting and editing features for commands specified as strings or arrays within the \[tasks\] section and the 'run' key of advanced task tables.
runtime/queries/miseconfig · high confidence
Add syntax highlighting and code navigation support for the Inko language
This change introduces initial support for the Inko programming language by adding a set of Tree-sitter query files (highlights, indents, injections, locals, tags, and textobjects) to the runtime queries directory. Users will now see Inko source files correctly highlighted with semantic tokens for keywords, operators, types, and functions, along with proper indentation rules, local variable scope detection, and text-object selections for classes, methods, and comments.
runtime/queries/inko · high confidence
Add syntax highlighting and comment injection for C3
This change introduces support for the C3 programming language by adding syntax highlighting rules and comment injection queries. Users will now see C3 source files correctly highlighted in editors that use Tree-sitter, with proper coloring for keywords, types, variables, and operators, as well as correct injection of comment syntax within C3 code.
runtime/queries/c3, runtime/queries/jsonnet · high confidence
Add syntax highlighting and diff injection for jjdescription files
Users editing jjdescription files now receive syntax highlighting for text, file paths, comments, and change types (Added, Deleted, Modified, Copied, Renamed). Additionally, content within scissors blocks is automatically injected as diff syntax for improved readability.
runtime/queries/jjdescription · high confidence
Add syntax highlighting and editing support for Batch files
This change introduces runtime query files for the Batch language, enabling syntax highlighting, indentation, text objects, and tag definitions in editors that use tree-sitter. Users will now see proper colorization for keywords, variables, and commands in .bat/.cmd files, along with improved indentation handling for parenthesized blocks and support for navigating comments and labels.
runtime/queries/batch · high confidence
Add syntax highlighting and editing support for the Picat language
Users can now edit Picat code with proper syntax highlighting, indentation, and text object selection. This change adds runtime query files for the Picat language, defining how operators, keywords, functions, and variables are highlighted, how indentation is calculated for blocks like predicates and loops, and how text objects (functions, parameters, comments) are selected for navigation.
runtime/queries/amber, runtime/queries/picat · high confidence
Add syntax highlighting and folding for Blade template files
New query files (folds, highlights, injections, rainbows, textobjects) are added to the Blade runtime directory, enabling syntax highlighting, code folding, and language injection for PHP, JavaScript, and comments within Blade templates. This includes support for Blade directives, Livewire attributes, and Alpine.js bindings.
runtime/queries/blade · high confidence
Add syntax highlighting and folding for Kconfig files
Users can now get syntax highlighting, code folding, and indentation support for Kconfig configuration files. This change adds specific query files (folds, highlights, indents, injections, locals) to the runtime/queries/kconfig directory, enabling features like keyword highlighting for config directives, symbol recognition, and proper nesting for menus and choices.
runtime/queries/fidl, runtime/queries/kconfig, runtime/queries/thrift · high confidence
Add syntax highlighting and folding for MediaWiki Wikitext
Users can now get syntax highlighting and code folding for MediaWiki Wikitext files. This change introduces query definitions for headings, links, templates, tables, and HTML tags, enabling better visual structure and navigation within the editor.
runtime/queries/wikitext · high confidence
Add syntax highlighting and folding support for Smali files
Users can now get syntax highlighting, code folding, and indentation for Smali (Android bytecode) files. This change adds query definitions for highlighting types, methods, fields, variables, parameters, labels, operators, keywords, and literals, as well as folding rules for directives and method/field definitions.
runtime/queries/smali · high confidence
Add syntax highlighting and indentation for Koka
Users can now edit Koka source files with proper syntax highlighting and automatic indentation. This change introduces highlight queries for Koka keywords, types, functions, and operators, along with indentation rules for function bodies, blocks, and control structures, ensuring code is formatted correctly as it is typed.
runtime/queries/koka · high confidence
Add syntax highlighting and indentation for LLVM MIR files
Users can now get syntax highlighting, indentation, and text object support for LLVM Machine IR (MIR) files. This change introduces new query files for the \llvm-mir\ language, including highlights for labels, comments, operators, keywords, and types specific to MIR syntax, as well as indentation rules for basic blocks and labels. It also adds text objects for selecting basic blocks, arguments, and comments, and configures injection queries to treat comments as comment language nodes.
runtime/queries/llvm-mir · high confidence
Add syntax highlighting and indentation for linker scripts
Users editing linker scripts (ld) now receive syntax highlighting and indentation support. This change introduces new query files for the ld language, defining highlights for identifiers, operators, keywords (such as SECTIONS, MEMORY, and ENTRY), built-in functions, and literals, along with indentation rules for structural elements like sections and memory blocks.
runtime/queries/ld · high confidence
Add syntax highlighting and indentation rules for CPON files
Users can now get proper syntax highlighting and indentation for CPON (Compact Property Object Notation) files. This change introduces highlight queries that colorize booleans, null, numbers, strings, escape sequences, and structural brackets, while indent queries ensure correct nesting for maps, arrays, and meta nodes.
runtime/queries/cpon · high confidence
Add syntax highlighting and indentation rules for the Move language
Users can now get syntax highlighting and proper indentation for Move code. This change introduces new \highlights.scm\ and \indents.scm\ files in the \runtime/queries/move\ directory, defining how Move-specific constructs like keywords, literals, functions, and module accesses are visually styled and how code blocks are indented.
runtime/queries/move · high confidence
Add syntax highlighting and indentation support for Cylc configuration files
Users can now edit Cylc workflow configuration files with improved syntax highlighting, indentation, and text object support. The new query files define highlighting for sections (top, sub, graph, runtime, task), Jinja2 expressions, comments, and specific Cylc syntax like task parameters and graph strings. Indentation rules are applied to section headers and line continuations. Additionally, bash scripting within Cylc settings (e.g., \script\ or \environment\ sections) is now injected for proper syntax highlighting.
(repo-wide) · high confidence
Add syntax highlighting and indentation support for Doxyfile
Users can now get syntax highlighting, indentation, and text object support for Doxyfile configuration files. The new queries define highlighting for comments, identifiers, booleans, numbers, strings, delimiters, and operators, while indentation rules align values under options. Text objects allow selecting entire option entries or comments, and comments are injected as comment language for further processing.
(repo-wide) · high confidence
Add syntax highlighting and indentation support for Puppet manifests
Users can now edit Puppet configuration files with proper syntax highlighting, indentation, and local variable tracking. This change introduces runtime query files for the Puppet language, defining how keywords, types, functions, operators, and literals are highlighted, how blocks and structures are indented, and how local scopes and references are resolved within the editor.
runtime/queries/puppet · high confidence
Add syntax highlighting and indentation support for Robot Framework files
Users can now get proper syntax highlighting and automatic indentation for Robot Framework (.robot) files. This change introduces highlight queries that colorize comments, keywords, variables, and control structures (such as FOR, WHILE, IF, and TRY blocks), along with indent queries that correctly handle the nesting and outdenting of keyword definitions, test cases, and control flow statements.
runtime/queries/robot · high confidence
Add syntax highlighting and injection queries for EEx templates
Added runtime query files for EEx (Embedded Elixir) templates to enable proper syntax highlighting and code injection. The new highlights.scm file defines keywords for EEx directives (such as \\<%\, \\<%=\, \\<%%\, \\<%%=\, and \%\>\) and comments, while injections.scm configures the editor to treat Elixir expressions within EEx directives and partial expressions as Elixir code, allowing for accurate syntax highlighting of embedded Elixir logic.
runtime/queries/eex, runtime/queries/vento · high confidence
Add syntax highlighting and injection queries for EJS and ERB templates
This change introduces runtime query files for Embedded JavaScript (EJS) and Embedded Ruby (ERB) templates. For EJS, it defines syntax highlighting rules for various tag delimiters (such as \\<%\, \\<%=\, \\<%-\) and configures language injection to treat HTML content as HTML and code blocks as JavaScript. For ERB, it provides similar injection logic, treating code blocks as Ruby, and explicitly inherits the EJS highlighting rules to ensure consistent visual treatment of template syntax across both languages.
runtime/queries/ejs · high confidence
Add syntax highlighting and injection queries for Forth
New syntax highlighting and injection query files are added for the Forth language, enabling proper visual distinction of keywords, control flow, I/O operations, operators, numbers, strings, and comments in supported editors. The injection query ensures that comments within Forth code are correctly identified and styled.
runtime/queries/forth · high confidence
Add syntax highlighting and injection queries for GJS/GTS files
New Tree-sitter query files (highlights.scm and injections.scm) are added to the runtime/queries/\_gjs directory to enable syntax highlighting and language injection for GJS and GTS files. This allows the editor to correctly highlight Glimmer opening and closing tags and to inject Glimmer template syntax highlighting into template strings used within GJS/GTS code, such as those passed to \hbs\ or embedded in \\<template\>\ tags.
_runtime/queries/\gjs · high confidence
Add syntax highlighting and injection queries for Ghostty configuration files
Users can now get syntax highlighting and improved code folding for Ghostty configuration files. This change introduces new highlight rules that distinguish between comments, keys, values (such as booleans, numbers, and strings), operators, and specific Ghostty constructs like keybinds, actions, and palette indices. Additionally, a basic injection query is added to treat comments within the configuration as comment language nodes, enabling better integration with comment-related features.
runtime/queries/ghostty, runtime/queries/woodpecker-ci · high confidence
Add syntax highlighting and injection queries for JSDoc comments
Users will now see improved syntax highlighting for JSDoc comments, including keywords, types, and numeric constants. Additionally, fenced code blocks within JSDoc (such as those in @example tags) are now injected with their specified language for proper syntax highlighting.
runtime/queries/jsdoc · high confidence
Add syntax highlighting and injection queries for Ledger files
Users editing Ledger files will now see improved syntax highlighting, including specific styles for comments, dates, quantities, accounts, commodities, and keywords like 'include' and 'account'. Additionally, comments and notes within Ledger files are now correctly injected as comment language nodes, ensuring consistent highlighting behavior for inline comments.
runtime/queries/ledger, runtime/queries/webc · high confidence
Add syntax highlighting and injection queries for Taskwarrior files
Added syntax highlighting and injection queries for Taskwarrior files, enabling better visual recognition of comments, datetimes, identifiers, and keywords within the editor.
runtime/queries/task · high confidence
Add syntax highlighting and injection queries for jj config, revsets, and templates
Users now get syntax highlighting and code injection support for jj configuration files. The \jjconfig\ queries inherit TOML highlighting and inject specific languages into config values: \jjtemplate\ for template definitions, \jjrevset\ for revset definitions, and the corresponding interpreter language (e.g., bash, python) for inline scripts in aliases. Additionally, dedicated highlight queries are provided for \jjrevset\ and \jjtemplate\ files to ensure proper syntax coloring for these embedded languages.
runtime/queries/jjconfig · high confidence
Add syntax highlighting and injection rules for PRQL queries
Users editing PRQL files will now see proper syntax highlighting for keywords, functions, operators, and literals, along with SQL syntax highlighting for embedded SQL strings and JSON highlighting for JSON literals within \from\_text\ calls.
runtime/queries/prql · high confidence
Add syntax highlighting and injection support for Pug templates
Users can now get syntax highlighting and code injection for Pug template files. The update adds highlight queries that colorize Pug-specific constructs such as doctypes, tags, attributes, control flow keywords (if, each, while), mixins, includes, inheritance blocks, and filters. It also enables JavaScript injection within Pug files, allowing embedded JavaScript code to be highlighted with the appropriate language rules.
runtime/queries/gotmpl, runtime/queries/pug · high confidence
Add syntax highlighting and injection support for cross-rs config files
Users editing cross-rs configuration files (typically TOML) now receive proper syntax highlighting and text object support inherited from the TOML language definition. Additionally, the 'pre-build' field is recognized for syntax injection, allowing bash scripts defined within that field to be highlighted as bash code.
runtime/queries/cross-config · high confidence
Add syntax highlighting and language injection for Edoc
Edoc documentation files now receive proper syntax highlighting and nested language injection support. The new highlight queries define semantic captures for section headings, tags, macros, inline and block quotes, and XHTML-style formatting tags. Additionally, content within block quotes and type macros is injected as Erlang, enabling accurate syntax highlighting for embedded code snippets within Edoc documents.
runtime/queries/edoc · high confidence
Add syntax highlighting and language injection for Glimmer templates
Users now get proper syntax highlighting and embedded language support for Glimmer templates (Ember.js). The new \highlights.scm\ file distinguishes HTML tags from Glimmer components, highlights variables, helpers, and control keywords, and formats literals and delimiters. Additionally, \injections.scm\ enables syntax highlighting for JavaScript inside \\<script\>\ tags and CSS inside \\<style\>\ tags within these templates.
runtime/queries/glimmer · high confidence
Add syntax highlighting and language support for KDL files
Users can now edit KDL (Key-Value Description Language) files with proper syntax highlighting, including support for comments, strings, numbers, and keywords. The update also introduces auto-indentation, rainbow bracket matching for improved readability, and text object selections for nodes, types, and comments. Additionally, specific injection queries enable syntax highlighting for regex patterns within window/layer rules and for fish shell scripts in spawn bindings.
runtime/queries/kdl · high confidence
Add syntax highlighting and local scope detection for Circom
Users editing Circom files now benefit from improved syntax highlighting and code intelligence. New query files define visual styles for identifiers, keywords (such as signal, template, and function), operators, and punctuation, while also establishing local scope boundaries for functions, templates, and main components to support features like symbol navigation and reference tracking.
runtime/queries/circom · high confidence
Add syntax highlighting and local tracking for Yara queries
New query files have been added for the Yara language to provide syntax highlighting and local variable tracking. The highlights configuration defines tokens for keywords (such as rule, meta, condition), operators, string modifiers, and built-ins, while the locals configuration identifies rule names and string identifiers for definition and reference contexts.
runtime/queries/yara · high confidence
Add syntax highlighting and local variable detection for VHDL
VHDL files now receive proper syntax highlighting and local variable support. The new \highlights.scm\ file defines capture groups for keywords, comments, built-in constants, and directives, while \locals.scm\ enables the detection of local scopes (subprograms and processes), definitions (parameters, signals, variables, constants), and references to identifiers within the code.
runtime/queries/vhdl · high confidence
Add syntax highlighting and local variable scoping for HDL
Users now get syntax highlighting and local variable support for HDL (Hardware Description Language) files. The new \highlights.scm\ file defines highlighting for keywords (CHIP, IN, OUT, PARTS, BUILTIN, CLOCKED), identifiers, and specific constructs like chip definitions and bus identifiers. The \locals.scm\ file establishes scoping rules, treating chip definitions as scopes and defining input/output/clocked pins as local variable parameters, while identifying chip pins in connections as local references.
runtime/queries/hdl · high confidence
Add syntax highlighting and local variable support for Tera templates
Users can now get syntax highlighting and local variable tracking for Tera template files. This change introduces query definitions for highlighting variables, literals, operators, tags, and built-in functions/filters, as well as injection support for YAML frontmatter. It also enables the identification of local variable definitions, references, and macro parameters within the editor.
runtime/queries/tera · high confidence
Add syntax highlighting and local variable support for the P language
Users of the P formal modeling language will now see improved code navigation and visual feedback in editors that support Tree-sitter. This change introduces syntax highlighting rules for P-specific constructs, including keywords (such as machine, state, and invariant), types, functions, and literals, as well as definitions for local variable scopes, function parameters, and references, enabling features like go-to-definition and symbol outlining for P code.
runtime/queries/p · high confidence
Add syntax highlighting and navigation queries for Ripple
New Tree-sitter query files (folds, highlights, injections, locals, rainbows, tags) have been added to the runtime/queries/ripple directory to enable syntax highlighting, code folding, bracket matching, symbol navigation, and scope resolution for the Ripple framework. These queries define how Ripple-specific constructs like components, fragments, server blocks, and reactive syntax are parsed and displayed in the editor.
runtime/queries/ripple · high confidence
Add syntax highlighting and navigation support for Docker Bake files
Users can now get syntax highlighting, folding, indentation, and code navigation (tags, text objects) for Docker Bake configuration files. The new queries inherit from the HCL language base and add specific injections for inline Dockerfiles and regex strings, enabling better editing experience for \docker-bake.hcl\ files.
runtime/queries/docker-bake · high confidence
Add syntax highlighting and navigation support for Metamath
Users can now edit Metamath files with improved visual feedback and code navigation. This change adds runtime query files that provide syntax highlighting for keywords, labels, and proof structures, as well as local variable tracking and tag generation for axioms, theorems, and hypotheses.
runtime/queries/metamath · high confidence
Add syntax highlighting and query support for R and R Markdown
New query files are added for the R and R Markdown languages, enabling syntax highlighting, indentation, tagging, and text object selection. The R queries define specific highlights for literals (including \na\, \null\, \inf\), operators, functions, and namespaces, while R Markdown inherits its query configuration from Markdown.
runtime/queries/r · high confidence
Add syntax highlighting and rainbow matching for regex queries
New highlight and rainbow query files are added for the regex language, enabling syntax highlighting and bracket matching for regex patterns. Highlights distinguish brackets, operators, escape sequences, quantifiers, inline flags, and character classes, while rainbow scopes group lookarounds, flags, character classes, capturing groups, and quantifiers for visual nesting clarity.
runtime/queries/regex · high confidence
Add syntax highlighting and tag queries for SlightLisp
This change introduces runtime query files for the SlightLisp language, enabling syntax highlighting and code navigation features. The \highlights.scm\ file defines patterns to color keywords (such as \if\, \let\, \def\, \mac\), functions, variables, strings, comments, and operators specific to SlightLisp syntax. The \tags.scm\ file adds support for generating tags for function definitions (\def\), external definitions (\ext\), and macro definitions (\mac\), allowing users to jump to these definitions within their editor.
runtime/queries/slisp · high confidence
Add syntax highlighting and tag queries for reStructuredText
New highlight and tag queries have been added for reStructuredText (RST) files, enabling proper syntax highlighting for elements like headings, links, lists, and directives, as well as supporting tag-based navigation via section definitions.
runtime/queries/rst · high confidence
Add syntax highlighting and tags for INI and systemd files
Users now get syntax highlighting and tag support for INI configuration files, with sections, comments, brackets, operators, and settings properly styled. Systemd unit files automatically inherit these INI-based queries, providing consistent highlighting and section tagging without requiring separate definitions.
runtime/queries/ini · high confidence
Add syntax highlighting and text object queries for GDScript
This change introduces the first set of tree-sitter query files for GDScript, enabling syntax highlighting, indentation rules, and text object selection within the editor. The new \highlights.scm\ file defines scopes for GDScript-specific elements such as class definitions, function calls, Godot built-in types (e.g., \Vector2\, \Dictionary\), and keywords, ensuring code is visually distinguished. Additionally, \indents.scm\ provides indentation logic for control structures and blocks, while \textobjects.scm\ allows users to select and operate on classes, functions, parameters, and comments as discrete units.
runtime/queries/gdscript, runtime/queries/graphql, runtime/queries/prisma · high confidence
Add syntax highlighting and text object queries for Godot resource files
This change introduces support for Godot resource files (\.tscn\, \.tres\) by adding new tree-sitter query files (\highlights.scm\, \injections.scm\, \tags.scm\, \textobjects.scm\). Users will now see syntax highlighting for sections, attributes, properties, and literals in resource files, along with improved code injection for embedded GLSL shaders and GDScript sources. Additionally, text objects are defined for sections, attributes, and properties, enabling navigation and selection features within resource definitions.
(repo-wide) · high confidence
Add syntax highlighting and text object support for SageMath
Users can now get syntax highlighting and text object navigation for SageMath files. The new query files in \runtime/queries/sage/\ inherit Python's highlighting and text object definitions, while also adding specific injection rules for comments.
runtime/queries/sage · high confidence
Add syntax highlighting and text object support for Tiltfiles
Users can now edit Tiltfiles with improved editor support, including syntax highlighting, indentation, and text objects. The new files in \runtime/queries/tilt\ inherit Python's base configuration for highlights, indents, rainbows, and text objects. Additionally, specific injection rules are added to highlight bash code within Tiltfile strings, such as those passed to \local\, \run\, \custom\_build\, \local\_resource\, and various command arguments like \cmd\ or \serve\_cmd\.
runtime/queries/tilt · high confidence
Add syntax highlighting and text object support for the Gren programming language
Users can now benefit from syntax highlighting and text object navigation for the Gren programming language. This change introduces new query files (highlights.scm, locals.scm, textobjects.scm) that define how Gren code is visually rendered and structurally parsed, including support for keywords, types, functions, variables, comments, and specific text objects like functions and parameters.
runtime/queries/gren · high confidence
Add syntax highlighting and text objects for Elm
New query files for the Elm language provide syntax highlighting (keywords, types, functions, comments, strings), local scope detection, tag definitions for navigation, rainbow bracket support, and text objects for selecting functions, parameters, and comments. This enables proper visual styling and structural editing capabilities for Elm source files.
runtime/queries/awk, runtime/queries/elm, runtime/queries/purescript · high confidence
Add syntax highlighting and text objects for HOCON configuration files
Users can now get syntax highlighting, indentation, and text object support for HOCON (Human-Optimized Config Object Notation) files. This change introduces new query files that define how HOCON elements like comments, strings, numbers, operators, and directives are highlighted, how object and array blocks are indented, and how comments and key-value pairs can be selected as text objects.
runtime/queries/hocon · high confidence
Add syntax highlighting and text objects for NASM assembly
Users can now get syntax highlighting and text-object support for NASM (Netwide Assembler) files. This change adds query files for highlights, injections, and text objects, enabling features like keyword, comment, and string highlighting, as well as the ability to select functions, classes, and comments within NASM code.
runtime/queries/nasm · high confidence
Add syntax highlighting and text objects for RsHtml templates
Users can now get syntax highlighting and text-object navigation for RsHtml template files. This change adds query definitions for RsHtml, including highlighting rules for HTML tags, Rust expressions, and control flow keywords, as well as injection queries to highlight embedded HTML and Rust code within the templates. Additionally, text objects are defined for Rust blocks, control flow statements (if, while, for), and component tags, enabling easier selection and manipulation of these structures in the editor.
runtime/queries/rshtml · high confidence
Add syntax highlighting and text objects for the Templ language
Users editing Templ files now receive syntax highlighting, semantic tagging, and text-object support. This change introduces query files for the Templ language that define highlights for components, CSS, and script blocks; inject JavaScript and CSS syntax into script/style elements; provide rainbow bracketing for expressions and tags; and enable text objects for navigating elements, components, and declarations.
runtime/queries/templ · high confidence
Add syntax highlighting and textobject queries for .env files
Users can now get syntax highlighting and textobject support for .env files. The new highlight queries inherit from bash, ensuring consistent visual styling, while the textobject queries allow users to select comments and variable assignments as distinct units.
runtime/queries/env · high confidence
Add syntax highlighting for Alloy configuration files
Users can now see syntax-highlighted Alloy configuration files in the editor. This change introduces a new highlight query file that defines visual styles for literals (booleans, strings, numbers, null), punctuation (brackets, delimiters, operators), function definitions, and attributes.
runtime/queries/alloy · high confidence
Add syntax highlighting for CEL and SpiceDB schema languages
Users will now see syntax highlighting for Common Expression Language (CEL) and SpiceDB schema files. This change introduces a new highlight definition file that maps operators, keywords, identifiers, function calls, and literals to specific visual themes, improving code readability and navigation within these languages.
runtime/queries/cel · high confidence
Add syntax highlighting for Django templates
Users will now see syntax highlighting for Django template files, including comments, template tags, variables, filters, and strings, as well as HTML injection for content within these templates.
runtime/queries/htmldjango · high confidence
Add syntax highlighting for EdgeDB Schema Language (ESDL)
Users will now see syntax highlighting for EdgeDB Schema Language (ESDL) files in supported editors. This change introduces a new highlight query file that defines visual styles for ESDL keywords (such as module, link, property), built-in types (like str, int64, json), identifiers, comments, and operators, improving code readability and navigation within schema definitions.
runtime/queries/esdl · high confidence
Add syntax highlighting for Flattened Device Tree (DTS) files
Users can now get syntax highlighting for Flattened Device Tree Source files. This change introduces a new highlight query file that defines syntax rules for keywords, preprocessor directives, operators, punctuation, strings, numbers, identifiers, functions, labels, properties, and comments, ensuring proper visual distinction of DTS language constructs.
runtime/queries/devicetree · high confidence
Add syntax highlighting for Go module and workspace files
Syntax highlighting support has been added for Go module (\go.mod\) and Go workspace (\go.work\) files. Keywords such as \require\, \replace\, \go\, \toolchain\, \tool\, \exclude\, \retract\, \module\, and \use\ are now highlighted, along with version strings and comments.
runtime/queries/gomod · high confidence
Add syntax highlighting for JSON-LD
Users editing JSON-LD files will now see specific syntax highlighting for JSON-LD keywords (such as @context, @type, and @id) and URLs, improving readability compared to generic JSON highlighting. This is achieved by introducing a dedicated language query set that inherits from the standard JSON configuration but adds targeted rules for JSON-LD syntax tokens.
(repo-wide) · high confidence
Add syntax highlighting for LPF files
Users will now see syntax highlighting for LPF (Logic Placement and Routing) files in supported editors. This change introduces a new highlight query file that defines keywords (such as SYSCONFIG, BLOCK, LOCATE, COMP, FREQUENCY, PORT, IOBUF), storage keywords (SITE), operators, numeric constants, strings, and comments, improving code readability and navigation for LPF design files.
(repo-wide) · high confidence
Add syntax highlighting for Mermaid diagrams in Markdown
Users will now see syntax-highlighted Mermaid diagrams (such as sequence, class, state, gantt, pie, flowchart, and ER diagrams) when viewing Markdown files. This change introduces a new highlight query file that maps Mermaid-specific keywords, nodes, arrows, and structural elements to standard syntax highlighting scopes, improving code readability and visual distinction within the editor.
runtime/queries/mermaid · high confidence
Add syntax highlighting for Pod documentation
Users now see syntax highlighting for Perl Pod documentation in nvim-treesitter. This change introduces a new highlight file that styles Pod commands (such as =head1 through =head6, =over, =item, and =encoding) as keywords or specific markup types, formats interior sequences (B, C, F, I, L, X) with appropriate styles like bold, literal, or link, and highlights escape sequences.
runtime/queries/pod · high confidence
Add syntax highlighting for RPM spec files
Users editing RPM spec files now benefit from syntax highlighting, which correctly identifies and colors macros, parameters, section names, scriptlets, and conditional directives. This enhancement improves code readability and navigation within spec files by providing visual distinction between different language constructs.
runtime/queries/rpmspec · high confidence
Add syntax highlighting for Rego (OpenPolicyAgent)
Users will now see syntax highlighting for Rego files in the editor. This change introduces highlight queries that define keywords, operators, strings, comments, and function calls, along with injection rules for comments, improving code readability and navigation within Rego policy files.
runtime/queries/rego · high confidence
Add syntax highlighting for Trace32 (T32) HLL scripts
Users can now see syntax-highlighted Trace32 High-Level Language (HLL) scripts in the editor. This change introduces new \highlights.scm\ and \injections.scm\ query files for the \t32\ language, defining visual styles for operators, keywords, literals, variables, functions, and control structures specific to the Trace32 scripting environment.
runtime/queries/t32 · high confidence
Add syntax highlighting for VHS scripts
Users now get syntax highlighting for VHS (Video Helper Script) files, with keywords like Set, Type, and Sleep, configuration options such as Theme and Framerate, and standard syntax elements like strings, comments, and numbers properly styled.
runtime/queries/vhs · high confidence
Add syntax highlighting for Xena OpenAutomation files
Users can now see syntax-highlighted Xena OpenAutomation (XTC) files in the editor. This change introduces a new highlight query file that maps XTC-specific syntax elements—such as parameters, change ports, templates, various argument types (hex, IPv4, numeric, string), comments, and brackets—to standard Tree-sitter highlight scopes.
runtime/queries/xtc · high confidence
Add syntax highlighting for dunst configuration files
Users editing dunst configuration files (dunstrc) will now see syntax highlighting support, including distinct styling for keys, comments, section brackets, operators, and section names.
runtime/queries/dunstrc · high confidence
Add syntax highlighting for git notes editmsg comments
Users will now see syntax highlighting applied to comments within git notes editmsg contexts. This change introduces a new highlight query file that maps comment nodes to the @comment highlight group, enabling visual distinction of comment text in the editor.
runtime/queries/git-notes · high confidence
Add syntax highlighting for strace logs
Users can now see syntax-highlighted strace logs, with syscalls, integers, pointers, values, strings, comments, and errors mapped to specific highlight groups for improved readability.
runtime/queries/strace · high confidence
Add syntax highlighting for the Bass language
Users can now see syntax-highlighted Bass code in the editor. This change introduces a new \bass\ language definition with a \highlights.scm\ file that maps Bass syntax elements—such as comments, punctuation, constants, strings, paths, and various keywords—to specific visual styles. It distinguishes between built-in functions, macros, control structures (like \if\, \case\, \each\), and special forms, ensuring that symbols are highlighted as variables or functions only in appropriate contexts.
(repo-wide) · high confidence
Add syntax highlighting for the ChucK programming language
Users can now see syntax-highlighted code for ChucK files. This change introduces a new \highlights.scm\ query file for the ChucK language, defining visual styles for keywords (such as \fun\, \if\, \while\), comments, strings, numbers, and function definitions, copied from the upstream tree-sitter-chuck repository.
runtime/queries/chuck · high confidence
Add syntax highlighting for todo.txt files
Users will now see syntax highlighting for todo.txt files, with tasks, priorities, dates, key-value pairs, projects, and contexts visually distinguished by specific color themes.
runtime/queries/todotxt · high confidence
Add syntax highlighting, code injection, and tag queries for Markdown
This change introduces the initial Treesitter query files for Markdown, enabling syntax highlighting, language injection, and navigation tags. The highlights.scm file defines styles for ATX and Setext headings, code blocks, links, lists (including task lists), block quotes, and tables. The injections.scm file allows code fences to inject their specified language (or detect language via shebang), injects HTML blocks as HTML, and injects inline Markdown and metadata (YAML/TOML) for nested syntax highlighting. The tags.scm file enables jumping to section headings by capturing them as definition sections.
runtime/queries/markdown · high confidence
Add syntax highlighting, folding, and injection support for Tree-sitter Query (TSQ) files
Users editing Tree-sitter Query files (.scm) now receive proper syntax highlighting, code folding, and regex injection. New query files in runtime/queries/tsq define highlights for TSQ-specific syntax including predicates (eq, not-eq, match, not-match, etc.), captures, and operators. Folding is enabled for named nodes, predicates, groupings, and lists. Regex strings within match/not-match predicates are injected for syntax highlighting. Rainbow delimiters are also added for brackets and scopes.
runtime/queries/tsq · high confidence
Add syntax highlighting, folding, and injection support for Vim script
New query files (folds.scm, highlights.scm, injections.scm, rainbows.scm) are added to runtime/queries/vim, enabling syntax highlighting, code folding, rainbow bracket matching, and language injection (for Lua, Ruby, Python, and regex) within Vim script files.
runtime/queries/vim · high confidence
Add syntax highlighting, indentation, and injection queries for Pkl
This change introduces the runtime query files for the Pkl language, enabling proper syntax highlighting, indentation, and code injection support. The highlights.scm file defines patterns for operators, keywords, literals, and identifiers to provide visual structure in the editor. The indents.scm file configures indentation rules for object bodies, class bodies, conditional expressions, and multi-line strings. Additionally, injections.scm enables regex highlighting within calls to the 'Regex' method and treats comments and documentation comments as injected content for appropriate syntax treatment.
runtime/queries/nickel, runtime/queries/pkl · high confidence
Add syntax highlighting, indentation, and injection queries for Vue single-file components
Users now get proper syntax highlighting, indentation, and code injection for Vue single-file components. The new \highlights.scm\ file provides specific highlighting for Vue directives, attributes, and template syntax. The \indents.scm\ file ensures correct indentation for template elements while respecting Vue conventions for script and style blocks. The \injections.scm\ file enables syntax highlighting for JavaScript and CSS within \\<script\>\ and \\<style\>\ tags, respecting the \lang\ attribute, and explicitly avoids injecting the template body to preserve native Vue template parsing. The \textobjects.scm\ file adds text object support for script, style, and template elements.
runtime/queries/vue · high confidence
Add syntax highlighting, indentation, and injection support for Fish shell
This change introduces comprehensive language support for the Fish shell by adding new query files (highlights, indents, injections, locals, and textobjects). Users will now see proper syntax highlighting for Fish keywords, commands, variables, and strings, along with correct indentation behavior for control structures like if/else, loops, and functions. Additionally, the editor can now inject syntax highlighting for embedded jq and Nushell (nu) code within Fish scripts, and textobject selections are available for functions and comments.
runtime/queries/fish · high confidence
Add syntax highlighting, indentation, and navigation queries for Protobuf files
Users editing .proto files now receive improved editor support through newly added tree-sitter query files. Syntax highlighting covers Protobuf keywords, types, variables, literals, and operators. Indentation rules are defined for message, enum, oneof, service, and RPC bodies. Navigation features include tag definitions for classes, functions, and constants, as well as text objects for selecting bodies of messages, enums, services, and RPCs.
runtime/queries/protobuf · high confidence
Add syntax highlighting, indentation, and rainbow bracket support for the Spade language
Users editing Spade code now receive proper syntax highlighting, automatic indentation, and rainbow bracket matching. The new query files define scopes for keywords (such as \pipeline\, \struct\, \match\), types, variables, and literals, while indentation rules handle constructs like \unit\_definition\, \struct\_definition\, and \match\_expression\. Rainbow brackets are configured to colorize nested scopes and delimiters including parentheses, braces, and angle brackets.
runtime/queries/janet, runtime/queries/spade · high confidence
Add syntax highlighting, indentation, and shell injection for Makefiles
New syntax queries have been added for the Makefile language to improve editing experience. Users will now see proper syntax highlighting for Make directives, variables, functions, and special targets. Indentation is automatically handled for define blocks and rules, with correct outdenting for endef. Additionally, shell commands within Makefiles are now highlighted as Bash code via language injection.
runtime/queries/make · high confidence
Add syntax highlighting, indentation, and tagging for FreeBASIC
This change introduces initial tree-sitter support for the FreeBASIC language by adding query files for syntax highlighting, indentation, tags, and text objects. Users will now see FreeBASIC code properly highlighted (keywords, types, functions, literals), correctly indented based on control structures like IF/WEND and FOR/NEXT, and have function/sub declarations recognized for navigation and tagging.
runtime/queries/freebasic · high confidence
Add syntax highlighting, indentation, and tagging support for BASIC
Users editing BASIC source files now receive proper syntax highlighting, including keywords, operators, comments, and variables, along with correct indentation behavior for FOR/NEXT blocks. The change also enables tag generation for variable definitions introduced by FOR and LET statements, and provides text object queries for selecting comments and FOR loops.
runtime/queries/basic · high confidence
Add syntax highlighting, indentation, and text object queries for the Ink language
Users of the Ink programming language now have access to comprehensive runtime query definitions, including syntax highlighting, indentation rules, local variable scoping, and text objects. The new \highlights.scm\ file provides detailed tokenization for Ink-specific constructs such as knots, stitches, choices, diverts, and built-in list functions, while \indents.scm\ ensures proper alignment for choice and gather blocks. Additionally, \locals.scm\ defines variable scopes for knots, stitches, and parameters, and \textobjects.scm\ enables selection of functions, classes, parameters, and comments.
runtime/queries/ink · high confidence
Add syntax highlighting, indentation, and text objects for LLVM IR
Users now get first-class support for the LLVM IR language in the editor. This change introduces query files that provide syntax highlighting (categorizing keywords, types, variables, and comments), correct indentation for function bodies and instructions, and text objects for selecting functions, structs, arguments, and comments. It also enables injection highlighting for comments within LLVM IR files.
runtime/queries/cmake, runtime/queries/dart, runtime/queries/llvm · high confidence
Add syntax highlighting, indentation, and text objects for SGF files
Users editing SGF (Smart Game Format) files now receive proper syntax highlighting for properties, values, and punctuation, automatic indentation for nested game trees, and text-object selections for properties, nodes, and game trees.
runtime/queries/sgf · high confidence
Add syntax highlighting, indentation, and textobject queries for LLVM TableGen
Users editing LLVM TableGen files now receive proper syntax highlighting (keywords, types, strings, comments, etc.), automatic indentation rules, and support for textobject-based selection and navigation (e.g., selecting inside/around classes, multiclasss, comments, and parameters).
runtime/queries/tablegen · high confidence
Add syntax highlighting, indentation, and textobject queries for OCaml
Users can now edit OCaml files with proper syntax highlighting, automatic indentation, and textobject navigation. This change introduces new query files for both standard OCaml (\.ml\) and interface (\.mli\) files, defining highlight scopes for keywords, types, functions, and operators, configuring indentation rules for structures and bindings, and enabling textobjects for functions, classes, and comments.
runtime/queries/ocaml · high confidence
Add syntax highlighting, indentation, and textobject queries for the V language
This change introduces the first set of runtime queries for the V programming language, enabling proper syntax highlighting, indentation behavior, and textobject selection in editors that support tree-sitter. The \highlights.scm\ file defines capture groups for comments, identifiers, functions, types, keywords, and literals, while \indents.scm\ specifies block structures like structs, functions, and control flow for correct indentation. Additionally, \injections.scm\ enables SQL syntax highlighting within SQL expressions, and \textobjects.scm\ allows users to select functions, parameters, and structs as text objects.
runtime/queries/v · high confidence
Add syntax highlighting, indentation, text objects, and comment injection for Odin
Users editing Odin source code now receive full syntax highlighting, automatic indentation, text object support, and comment injection. The new query files define keywords, operators, types, and built-ins for accurate coloring, specify indentation rules for blocks and declarations, enable text objects for procedures, parameters, comments, and classes, and inject comment syntax highlighting within Odin comments.
runtime/queries/odin · high confidence
Add syntax highlighting, local scope, and comment injection for OpenSCAD
Users now get syntax highlighting, local variable tracking, and comment injection support for OpenSCAD files. The runtime/queries/openscad directory introduces highlights.scm to colorize keywords, built-in modules (like cube, sphere, translate), functions, modules, variables, operators, and literals; locals.scm to define scopes (functions, modules, let/assign/for blocks) and track variable definitions and references; and injections.scm to enable comment injection within OpenSCAD source files.
runtime/queries/openscad · high confidence
Add syntax highlighting, local tracking, and rainbow delimiters for Fennel
This change introduces initial language support for Fennel by adding three new query files in the runtime/queries/fennel directory. The highlights.scm file defines syntax highlighting rules for Fennel constructs, including functions, keywords, operators, and built-ins. The locals.scm file enables local variable tracking for scopes like let, fn, and loops, as well as parameter and definition detection. The rainbows.scm file adds rainbow bracket highlighting for various Fennel forms to improve code readability.
runtime/queries/fennel · high confidence
Add syntax highlighting, local tracking, and text objects for Pascal
This change introduces the first-class support for the Pascal language by adding query files (highlights, locals, textobjects, and injections) to the runtime. Users will now see syntax highlighting for Pascal code, including identifiers, keywords, types, and literals; local variable and procedure/function definitions and references are tracked for navigation; and text objects allow for selecting classes, functions, parameters, and comments.
runtime/queries/pascal · high confidence
Add syntax highlighting, text objects, and code injection for Dockerfiles
Introduces support for Dockerfile syntax in the editor, including keyword highlighting for instructions like FROM, RUN, and COPY, as well as strings, comments, and heredocs. Users can now use text objects to select comments and have shell commands within RUN instructions and heredocs injected as Bash for improved syntax highlighting and editing support.
runtime/queries/dockerfile · high confidence
Added NestedText language support
Users can now use NestedText files with syntax highlighting, indentation, injection, and text object queries. These query files inherit their behavior from the existing YAML configuration, ensuring consistent editing experiences for NestedText documents.
runtime/queries/nestedtext · high confidence
Added PTX syntax highlighting and indentation support
Users can now get syntax highlighting and proper indentation for PTX (Parallel Thread Execution) source files. This change introduces new query files (\highlights.scm\, \indents.scm\, \folds.scm\) that define how PTX directives, keywords, types, instructions, registers, and other elements are visually presented and structured in the editor.
runtime/queries/ptx · high confidence
Added placeholder for runtime grammar libraries
A .gitkeep file was added to the runtime/grammars directory to ensure the folder is tracked in version control, establishing a location for dynamically loaded grammar libraries.
runtime/grammars · low confidence
Added syntax highlighting and code injection for git-rebase files
Users editing git-rebase todo files now receive syntax highlighting that distinguishes between commands acting on commits (like pick, reword, squash) and those acting on labels (like label, reset), as well as specific styles for exec, fixup, and merge commands. Additionally, the content of exec commands is injected as Bash code, enabling syntax highlighting and other language features within those script blocks.
runtime/queries/git-rebase · high confidence
Added syntax highlighting and comment injection for .gitignore files
Users will now see improved syntax highlighting in .gitignore files, with distinct visual styles for pattern characters, directory separators, negations, wildcards, and bracket expressions. Additionally, comments within .gitignore files are now correctly injected as comment language nodes, ensuring consistent formatting and highlighting behavior across the editor.
runtime/queries/git-ignore · high confidence
Added syntax highlighting and folding for Tcl
Users can now see Tcl code properly highlighted in the editor. This change introduces syntax highlighting rules for Tcl commands, keywords, variables, and built-ins, along with folding support for braced words and indentation guides for control structures and procedures.
runtime/queries/tcl · high confidence
Added syntax highlighting and folding for Terraform variable files
The editor now supports \.tfvars\ files by adding specific query definitions for folds, highlights, indents, and injections. These queries inherit their behavior from the existing HCL (HashiCorp Configuration Language) rules, ensuring that Terraform variable files receive consistent syntax highlighting, code folding, and indentation handling.
runtime/queries/tfvars · high confidence
Added syntax highlighting and indentation rules for TQL
Added syntax highlighting and indentation rules for the TQL language, enabling proper code formatting and visual distinction of keywords, operators, variables, and other language constructs in the editor.
runtime/queries/tql · high confidence
Added syntax highlighting and indentation rules for WIT files
Users will now see proper syntax highlighting and indentation for WIT (WebAssembly Interface Types) files. This change introduces highlight queries that colorize comments, types, functions, variables, keywords, and operators, as well as indent queries that correctly handle nesting for use items, fields, variants, flags, enums, unions, arguments, and resources.
runtime/queries/wit · high confidence
Added syntax highlighting and injection for GitHub Action workflows
New query files have been added to the runtime/queries/github-action directory to provide syntax highlighting, indentation, rainbows, and text objects for GitHub Action workflow files, inheriting YAML rules. Additionally, JavaScript injection is now supported for inline and block script content within actions using the 'actions/github-script' action, enabling proper syntax highlighting for embedded JavaScript code.
runtime/queries/github-action · high confidence
Added syntax highlighting and injection queries for IEx
New highlight and injection query files for IEx have been added to the runtime queries directory. The highlight query defines the IEx prompt as a comment, while the injection queries ensure that code blocks and results within the IEx session are highlighted as Elixir, improving syntax recognition in mixed-language buffers.
runtime/queries/embedded-perl, runtime/queries/iex · high confidence
Added syntax highlighting and injection queries for Nginx configuration files
Users can now benefit from improved syntax highlighting and language injection support for Nginx configuration files. This change introduces highlight queries that distinguish between block directives, simple directives, comments, punctuation, and various value types (strings, numbers, variables). Additionally, it enables injection of Lua code, regular expressions, and comments within Nginx configs, allowing for more accurate syntax highlighting of embedded content.
runtime/queries/nginx · high confidence
Added syntax highlighting and language support for Haskell Persistent
Users now get syntax highlighting, folding, and tag generation for the Haskell Persistent library via new \haskell-persistent\ query files. The \highlights.scm\ file defines scopes for Persistent-specific keywords (e.g., \Id\, \Primary\, \Foreign\), types, and constructors, while \folds.scm\ enables folding for entity definitions. Additionally, the main Haskell \injections.scm\ now injects \haskell-persistent\ syntax highlighting into quasiquote bodies when using specific persisters like \persistWith\, \persistLowerCase\, or \persistUpperCase\.
runtime/queries/haskell · high confidence
Added syntax highlighting and local scope detection for TLA+ and PlusCal
Users can now benefit from improved code navigation and visual clarity in TLA+ and PlusCal files. This change introduces syntax highlighting rules for TLA+ keywords, literals, and operators, as well as PlusCal-specific constructs. Additionally, it defines local scope and definition references for modules, operators, variables, and proof steps, enabling features like 'go to definition' and symbol highlighting within the editor.
runtime/queries/tlaplus · high confidence
Added syntax highlighting and semantic tagging for SpiceDB CEL caveats
Users editing SpiceDB schema files will now see improved syntax highlighting and semantic navigation support for CEL (Common Expression Language) caveats. This change introduces highlight rules for CEL-specific identifiers (such as \cel\_type\_identifier\ and \cel\_variable\_identifier\) and operators, and configures language injection so that code within caveat expressions is highlighted using CEL syntax rules. Additionally, tags are provided to enable go-to-definition and reference-finding for object definitions.
runtime/queries/spicedb · high confidence
Added syntax highlighting and text object queries for Penrose files
Users can now benefit from improved code navigation and visual clarity in Penrose files. This change introduces syntax highlighting rules that distinguish keywords, types, functions, and operators, as well as text object queries that allow for easier selection of functions, predicates, and parameters. Additionally, LaTeX content within labels is now correctly injected for syntax highlighting.
runtime/queries/penrose · high confidence
Added syntax highlighting and text object support for GNU Assembler (gas)
Users can now benefit from improved editing experience for GNU Assembler (gas) files, including syntax highlighting for directives, instructions, registers, and operands, as well as text object queries for selecting comments.
runtime/queries/gas · high confidence
Added syntax highlighting and text objects for Dhall
Users can now get syntax highlighting and improved navigation for Dhall files. This change adds highlight queries for literals, imports, comments, types, variables, keywords, operators, and builtins, as well as injection queries for comments. It also introduces textobject queries for lambda expressions, forall expressions, assert expressions, and comments, enabling better code selection and manipulation.
runtime/queries/dhall · high confidence
Added syntax highlighting and text objects for mail files
Users can now get syntax highlighting and text object support for mail files. The change introduces highlight queries that colorize email headers, subjects, addresses, and quoted replies, as well as rainbow bracketing for quoted blocks. Additionally, text objects are defined for atoms, email addresses, headers, quoted blocks, body blocks, and subjects, enabling easier navigation and selection of these elements.
runtime/queries/mail · high confidence
Added syntax highlighting and text-object support for JSON5
New query files have been added to the runtime/queries/json5 directory to provide syntax highlighting, indentation, rainbow bracket, and text-object support for JSON5 files. This enables proper visual distinction of JSON5-specific elements such as booleans, null, numbers, strings, comments, and member keys, while also allowing users to select and operate on JSON5 structures like objects, arrays, and comments using text objects.
(repo-wide) · high confidence
Added syntax highlighting for Debian control files
Syntax highlighting support has been added for Debian control files, enabling visual distinction for comments and field names within the editor.
runtime/queries/debian · high confidence
Added syntax highlighting for GN build files
Users can now see syntax-highlighted GN (Generate Ninja) build configuration files. This change introduces new query files (\highlights.scm\ and \injections.scm\) that define how GN-specific elements such as variables, functions, control keywords, operators, strings, and comments are visually distinguished in the editor.
runtime/queries/gn · high confidence
Added syntax highlighting for GPR (Ada Project) files
Users now get syntax highlighting for GPR files, with keywords, operators, comments, strings, and specific constructs like project declarations, qualifiers, and package names properly styled.
runtime/queries/gpr · high confidence
Added syntax highlighting for Jinja and Nunjucks templates
Users now get syntax highlighting for Jinja and Nunjucks template files. The change introduces highlight queries for Jinja (defining styles for expressions, statements, keywords, comments, identifiers, and operators) and configures Nunjucks to inherit these same highlighting rules. Additionally, Jinja files are configured to inject HTML highlighting for their content.
runtime/queries/jinja, runtime/queries/nunjucks · high confidence
Added syntax highlighting for Nearley grammar files
Users will now see syntax-highlighted Nearley grammar files in their editor. This change introduces highlight queries that colorize comments, strings, identifiers, rules, directives, tokens, and operators, along with rainbow bracket matching for groups and injection support for JavaScript content within control blocks.
runtime/queries/nearley · high confidence
Added syntax highlighting for SSH client configuration files
A new syntax highlighting query file (highlights.scm) has been added for the SSH client configuration grammar. This change enables proper visual distinction of SSH configuration directives, such as host names, match blocks, boolean flags, and file paths, within the editor.
_runtime/queries/ssh\_client\config · high confidence
Added syntax highlighting for WebAssembly Text (WAT/WAST) format
Users editing WebAssembly Text files will now see syntax highlighting for keywords, functions, strings, comments, and numeric constants. This change introduces new highlight query files for both the standard WAT format and the WAST test format, ensuring that identifiers, control flow, and module structures are visually distinguished in the editor.
runtime/queries/wat · high confidence
Added syntax highlighting for hosts queries
Added a new \highlights.scm\ file for the \hosts\ query language that defines syntax highlighting rules, specifically mapping \comment\ nodes to the \@comment\ highlight group, \ip\ nodes to \@namespace\, and \host\ nodes to \@string\.
runtime/queries/hosts · high confidence
Added syntax highlighting for passwd files
Users will now see syntax highlighting for passwd file contents, with specific nodes like usernames, authentication tokens, UIDs, GIDs, GECOS fields, home directories, and shells mapped to distinct highlight groups.
runtime/queries/csv, runtime/queries/passwd, runtime/queries/varlink · high confidence
Added syntax highlighting for the Elvish shell language
Users can now see syntax-highlighted code for Elvish scripts. This change introduces highlight rules for keywords (such as \if\, \while\, \fn\), variables, functions, operators, and comments, along with an injection rule for comments.
runtime/queries/elvish · high confidence
Added syntax highlighting for the Werk language
Users can now see syntax-highlighted code for the Werk language in their editors. This change introduces a new highlight configuration file that defines visual styles for Werk-specific keywords (such as build, task, and run), control structures, built-in functions (like error, glob, and read), and various operators.
runtime/queries/werk · high confidence
Added syntax highlighting, symbol tagging, and code injection for StrictDoc files
This change introduces Tree-sitter query files for the StrictDoc language, enabling syntax highlighting, symbol navigation, and code injection support in editors. The highlights.scm file defines keywords, built-in types, operators, and string literals specific to StrictDoc's document structure. The tags.scm file maps StrictDoc elements like documents, sections, and requirements to standard symbol definitions, allowing users to navigate the document structure via symbol pickers. The injections.scm file configures the editor to treat text parts within StrictDoc documents as reStructuredText (RST), enabling proper syntax highlighting for embedded RST content.
runtime/queries/strictdoc · high confidence
Automated documentation generation and syntax query validation
The xtask tool now includes a docgen task that automatically generates Markdown documentation for typable commands, static commands (including their default keybindings), and language support features (including tree-sitter capabilities and bundled language servers). Additionally, it introduces query-check and indent-check tasks to validate syntax queries and indentation behavior against test corpora, ensuring consistency and correctness of language definitions.
xtask · high confidence
Expanded comment tag highlighting with new severity levels
The comment highlighting rules now recognize a broader set of tags across hint, info, warning, and error levels. New hint tags include MARK, PASSED, STUB, MOCK, and TIP. Info-level tags have been expanded to include TODO, TO-DO, PERF, OPTIMIZE, PERFORMANCE, QUESTION, ASK, REVIEW, PR, and CR. Warning tags now cover HACK, WARN, WARNING, TEST, and TEMP. Error-level tags include BUG, FIXME, ISSUE, XXX, FIX, SAFETY, FIXIT, FAILED, DEBUG, INVARIANT, COMPLIANCE, PANIC, and SECURITY. Additionally, issue numbers (e.g., \#123) are highlighted as constants, user mentions (@user) as tags, and URIs as links.
runtime/queries/comment · high confidence
Initial Ada language support
Adds initial support for the Ada programming language, introducing syntax highlighting, code folding, local scope detection, text object selections, and comment injection queries. This enables users to edit Ada files with proper visual styling, structural folding, and navigation capabilities.
runtime/queries/ada · high confidence
Initial C++ syntax queries for highlighting, navigation, and editing
Adds the first dedicated C++ query files (highlights, indents, injections, locals, rainbows, tags, and textobjects) to provide C++-specific syntax support. This enables accurate highlighting for C++ constructs like \auto\, lambdas, and templates, correct indentation for access specifiers, tag generation for classes and namespaces, and text-object selection for lambda bodies and class scopes.
runtime/queries/cpp · high confidence
Initial C/C++ language support with syntax highlighting, indentation, and text objects
This change introduces the first official runtime queries for the C language (and EBNF), enabling core editing features. Users will now see proper syntax highlighting for C code, including keywords, types, variables, and preprocessor directives. The editor also gains intelligent indentation logic for C constructs like function calls and binary expressions, as well as text objects for navigating functions, structs, enums, and comments. Additionally, local variable scopes and tag definitions (functions, types, structs) are now recognized, improving navigation and refactoring capabilities.
(repo-wide) · high confidence
Initial Julia tree-sitter query support
Adds the first set of tree-sitter queries for Julia, enabling syntax highlighting, indentation, folding, text objects, tags, and local variable tracking. The highlighting queries distinguish between functions and constructors (using PascalCase rules), identify built-in functions and types, and inject syntax highlighting for markdown, bash, and regex within string literals. Indentation rules are defined for structural blocks like functions, structs, and control flow, while text objects allow selection of functions, classes, parameters, and comments.
runtime/queries/json, runtime/queries/julia, runtime/queries/ruby · high confidence
Initial Kotlin query support for syntax highlighting, folding, and navigation
This change introduces the first set of runtime query files for the Kotlin language, enabling core editing features. Users will now see Kotlin code properly highlighted (identifiers, keywords, operators, literals, annotations), have code regions foldable (imports, classes, functions, lambdas), and benefit from improved indentation handling. Additionally, the update adds text objects for selecting functions, classes, and comments, local variable scoping for navigation, rainbow delimiters for brackets, and tag queries for jumping to class and function definitions.
runtime/queries/kotlin · high confidence
Initial Lua and Lua Pattern language support
Adds comprehensive syntax highlighting, indentation, folding, tagging, and textobject queries for Lua and Lua pattern (luap) languages. This includes specific highlighting for Lua format strings via injection, enabling proper syntax recognition for patterns within string.match and string.format calls.
runtime/queries/lua · high confidence
Initial MATLAB/Octave query definitions for syntax highlighting and editing
Added the first set of runtime query files for MATLAB and Octave, enabling syntax highlighting, indentation, folding, and text object selection. These new files define how the editor recognizes and formats MATLAB code, including specific rules for keywords, operators, strings, and control structures like loops and conditionals.
runtime/queries/matlab · high confidence
Initial Nix language support with syntax highlighting and code navigation
This change introduces the first runtime support for the Nix language, adding a complete set of tree-sitter queries to \runtime/queries/nix\. Users will now see syntax highlighting for Nix expressions, including specific styling for builtins, higher-order function arguments, and pipe operators. The update also enables code folding for expression blocks (like \let\, \if\, and attrsets), proper indentation handling for Nix's expression-based structure, and code navigation features such as tag generation and local variable resolution. Additionally, it provides language injection for embedded scripts (e.g., Python in \testScript\, Bash in \writeShellScript\) and rainbow delimiters for bracket matching.
runtime/queries/erlang, runtime/queries/java, runtime/queries/nix · high confidence
Initial PHP syntax queries for highlighting, indentation, and text objects
This change introduces the first set of Tree-sitter query files for PHP, enabling syntax highlighting, indentation, and text object support. The \highlights.scm\ file defines scopes for variables, types, functions, keywords (including \clone\ and \unset\), and attributes. The \indents.scm\ file configures indentation rules for structures like arrays, switch blocks, and property hooks, while \textobjects.scm\ adds support for selecting classes, functions, parameters, and array entries. Additionally, \injections.scm\ enables syntax highlighting for HTML within PHP tags, regex in \preg\\\ function calls, and SQL in \mysqli\\\ and \prepare\/\query\ calls.
runtime/queries/php · high confidence
Initial Python syntax queries for highlighting, indentation, and navigation
This change introduces the complete set of Tree-sitter query files for Python, enabling syntax highlighting, indentation logic, text objects, and tag generation. Users will now see Python code highlighted with specific captures for keywords, operators, parameters (including keyword arguments and splats), and types; indentation is handled via new rules that support control flow, pattern matching, and alignment within parameters and arguments; and navigation features like text objects for functions, classes, parameters, and list entries are now available.
runtime/queries/bash, runtime/queries/python · high confidence
Initial SQL syntax highlighting, rainbow delimiters, and text objects
Users can now use SQL syntax highlighting, rainbow delimiters, and text objects in the editor. This change adds the initial query files for the SQL language, including \highlights.scm\ for syntax coloring (keywords, strings, comments, numbers, functions, etc.), \rainbows.scm\ for matching parentheses and brackets, and \textobjects.scm\ for selecting comments.
runtime/queries/sql · high confidence
Initial Svelte syntax queries for folding, highlighting, and injection
This change introduces the first set of Tree-sitter query files for Svelte, enabling core editing features such as code folding, syntax highlighting, indentation, and language injection. Users will now see Svelte components correctly highlighted, with HTML, CSS, JavaScript, and TypeScript content inside \\<script\>\ and \\<style\>\ tags properly injected and highlighted. The queries also define folding regions for blocks like \if\, \each\, \await\, and \snippet\, and support text objects for navigating elements and snippets.
runtime/queries/svelte · high confidence
Initial SystemVerilog syntax highlighting support
Added a new \highlights.scm\ query file for the SystemVerilog language, enabling syntax highlighting for keywords, comments, strings, operators, declarations, types, and module/interface instances in editors that use tree-sitter.
runtime/queries/systemverilog · high confidence
Initial YAML language support with syntax highlighting and injection
This change introduces the first complete YAML language definition for the editor, adding syntax highlighting, indentation rules, and code injection capabilities. Users will now see YAML files correctly highlighted, including booleans, strings, numbers, and special characters, with proper indentation handling for block sequences and mappings. Additionally, inline Bash scripts within YAML files (specifically for GitHub Actions and Buildkite \run\/\command\/\commands\ fields) are now injected and highlighted as Bash code, improving readability for CI/CD configurations.
runtime/queries/yaml · high confidence
Initial implementation of the Debug Adapter Protocol (DAP) client
Helix now includes a dedicated \helix-dap\ crate that implements the Debug Adapter Protocol, enabling users to debug programs directly within the editor. This change introduces a client capable of managing debugger processes via standard I/O or TCP connections, handling the full lifecycle of debug sessions including initialization, launching, and attaching. It supports core debugging features such as setting breakpoints, stepping through code, inspecting variables and scopes, and handling thread states. The implementation also includes transport-agnostic message parsing using \sonic\_rs\ for performance, manages multiple debugger instances via a registry, and surfaces progress events and output to the user interface.
helix-dap · high confidence
Initial release of Helix 0.0.10
This commit introduces the initial version of the Helix editor (v0.0.10), establishing the core configuration and build infrastructure. It adds the \languages.toml\ file to define supported languages and their associated tree-sitter grammars, along with the \default.nix\ and \flake.nix\ files to configure the Nix build environment and development shell. The release also includes the \base16\_theme.toml\ to provide a default color scheme, the \logo.svg\ assets, and \.gitattributes\ to configure Git diff drivers for source files.
(repo-wide) · high confidence
Initial syntax highlighting and indentation support for Scheme
Added comprehensive query files for the Scheme language, enabling syntax highlighting, indentation, and code navigation features. The new \highlights.scm\ defines tokens for numbers, strings, comments, operators, built-in procedures, and special forms like \lambda\ and \define-values\. The \indents.scm\ file implements indentation rules that align code based on list structures and keywords, following standard Scheme conventions. Additionally, \locals.scm\ provides scope and definition detection for variables and parameters, \tags.scm\ supports function and constant tagging, \rainbows.scm\ adds bracket matching, and \textobjects.scm\ enables comment selection.
runtime/queries/scheme, runtime/queries/zig · high confidence
Initial syntax highlighting and injection support for Org mode
Users can now see Org mode files highlighted in the editor with proper styling for headings, bold, italic, and inline code. The editor also supports syntax injection within Org blocks, allowing code inside these blocks to be highlighted according to its specific language.
runtime/queries/org · high confidence
Initial syntax highlighting and text object support for Solidity
Adds comprehensive syntax highlighting, local scope detection, rainbow bracket matching, and text object queries for Solidity source files. Users will now see Solidity code properly colored (identifiers, keywords, types, literals, etc.), have correct local variable scoping for navigation features, rainbow highlighting for nested brackets and blocks, and the ability to select function bodies, parameters, and other structural elements using text objects.
(repo-wide) · high confidence
Initial syntax highlighting, tagging, and text object support for git-config files
This change introduces the first set of Tree-sitter queries for the \git-config\ language, enabling structural understanding of \.gitconfig\ and similar files. Users will now see syntax highlighting for section headers, variables, values (including booleans, integers, and strings), and comments, with specific highlighting for \include\ and \includeIf\ directives. Additionally, the \xfuncname\ and \wordRegex\ configuration values are injected as regex for improved syntax awareness. The update also adds tag definitions for section names and text objects to allow selection of comments and configuration entries.
runtime/queries/git-config · high confidence
Initial tree-sitter based syntax support for Perl
Adds comprehensive syntax highlighting, folding, indentation, and text-object queries for Perl files. This enables proper code navigation, structural folding (e.g., for subroutines, blocks, and packages), and improved editing experience through tree-sitter parsing, replacing previous or missing support.
runtime/queries/perl · high confidence
Initial tree-sitter query support for TOML files
This change introduces the first set of tree-sitter queries for TOML, enabling syntax highlighting, indentation, rainbow brackets, tags, and text objects. Users will now see TOML tables, keys, and values highlighted with appropriate scopes (e.g., \@type\ for table headers, \@variable.other.member\ for keys), while multi-line arrays and inline tables are correctly indented. Rainbow scopes help visually distinguish nested structures, and text objects allow for easier selection of pairs, arrays, and comments.
runtime/queries/toml · high confidence
Inline Markdown syntax highlighting and injection rules
Added syntax highlighting and language injection rules for inline Markdown content. Inline code spans, links, images, and emphasis are now highlighted with appropriate markup styles. Additionally, HTML tags and LaTeX blocks embedded within inline Markdown are injected for syntax highlighting, with HTML injection configured to include unnamed children and combine content.
runtime/queries/markdown.inline · high confidence
Inline diagnostic rendering with distinct theme keys
Helix now supports rendering diagnostics inline within the editor buffer rather than only at the end of the line. This change introduces a new \InlineDiagnostics\ component that accumulates and draws diagnostic messages directly into the text area, using specific theme keys (\hint.diagnostic.inline\, \info.diagnostic.inline\, \warning.diagnostic.inline\, \error.diagnostic.inline\) to style each severity level distinctly. The implementation handles multi-line diagnostic messages and stacks multiple diagnostics vertically with visual connectors, allowing users to see error and warning details in context without scrolling to the end of the line.
_helix-term/src/ui/text\decorations · high confidence
Inline helix-tui fork with expanded cell styling and layout engine
The terminal UI library has been inlined as a dedicated \helix-tui\ crate, introducing a new \Cell\ structure that caches symbol display width for performance and supports distinct \underline\_color\ and \underline\_style\ properties. The library now includes a \Layout\ module powered by the \cassowary\ constraint solver for precise area splitting, a \symbols\ module providing standardized box-drawing and bar characters, and a \Terminal\ interface that manages double-buffered rendering and supports runtime configuration for mouse capture, extended underlines, and the Kitty keyboard protocol.
helix-tui/src · high confidence
Introduce LSP code action prioritization and inline diagnostics configuration
The editor now sorts LSP code actions in the menu using a priority system that mimics VSCode's behavior, grouping them by category (e.g., quickfix, refactor) and highlighting those that fix diagnostics or are marked as preferred. Additionally, a new configuration section for inline diagnostics has been added, allowing users to control the visibility and severity filtering of diagnostics displayed directly in the code buffer for both the cursor line and other lines.
helix-view/src · high confidence
Introduce custom documentation site with version awareness and syntax highlighting
The project now includes a dedicated mdBook-based documentation site located in the \book/\ directory. This introduces a custom 'colibri' theme with a dark color scheme and improved typography, alongside custom JavaScript to provide syntax highlighting for Tree-sitter Query (\.scm\/\.tsq\) files. A key behavioral addition is the runtime detection of the documentation channel (stable, nightly/master, or archived version), which displays a banner to users indicating whether they are viewing current, development, or outdated documentation, and provides a link to the latest release.
book · high confidence
Introduce helix-event crate for decoupled editor communication
The new helix-event crate provides a decoupled event system for the editor, allowing components to communicate without strong coupling. It introduces synchronous hooks for immediate state modifications (like hiding popups) and asynchronous hooks with debouncing for background tasks. The crate also includes utilities for managing task cancellation, requesting UI redraws, and displaying status messages, enabling more robust and responsive editor behavior.
helix-event · high confidence
Introduce helix-stdx crate for standard library extensions
A new \helix-stdx\ crate has been created to house shared standard library extensions, consolidating previously scattered utilities into a single module. This includes environment helpers in \env.rs\ (such as \current\_working\_dir\, \which\, and POSIX-style environment variable expansion), cross-platform file access and metadata management in \faccess.rs\ (handling permissions, hardlinks, and ACLs), path normalization and tilde expansion in \path.rs\, a custom \Range\ type with optimized subset checking in \range.rs\, and \RopeSlice\ extensions for grapheme and character boundary handling in \rope.rs\. Additionally, a lightweight RFC3986-compliant URI wrapper is provided in \uri.rs\ to replace the heavier \url\ crate for LSP file path conversions.
helix-stdx/src · high confidence
JSX syntax highlighting and rainbow bracket support
JSX files now inherit syntax queries from the shared ECMA and JavaScript bases, ensuring consistent highlighting and indentation behavior. Additionally, rainbow bracket highlighting has been added for JSX elements, allowing users to visually track matching opening, closing, and self-closing tags.
runtime/queries/jsx · high confidence
Native path and word completion providers added
Helix now includes built-in completion providers for file paths and words from open buffers, in addition to existing Language Server Protocol (LSP) completions. The new path completion (enabled via \editor.path-completion\) scans the filesystem to suggest files and directories, displaying type, permissions (on Unix), and full paths in the documentation. The word completion feature (enabled via \editor.word-completion\) suggests words found in the current document based on a configurable trigger length. These native providers are integrated into the completion handler alongside LSP results, with LSP items taking priority over path and word suggestions.
helix-term/src/handlers/completion · high confidence
New HTML syntax highlighting, indentation, and text object support
This change introduces comprehensive syntax support for HTML files by adding new query definitions. Users will see improved highlighting for tags, attributes, entities, and punctuation, including specific styling for URLs in href/src attributes and bold/italic/strikethrough text based on semantic tags like \<strong\> or \<em\>. Indentation logic now correctly handles element nesting, end tags, and self-closing tags, while also delegating script and style body indentation to their respective language engines. Additionally, the editor now supports text objects for selecting HTML elements and comments, and injects syntax highlighting for JavaScript, CSS, and regex content within script, style, and input pattern attributes respectively.
runtime/queries/html · high confidence
New LSP-driven inline features and improved editor behavior
This update introduces several new inline visual features powered by the Language Server Protocol: color swatches are now displayed inline in the gutter for documents that support document colors, and document links are highlighted inline for navigation. Additionally, auto-document highlights now automatically mark all occurrences of the identifier under the cursor, and code action hints are shown inline to suggest available fixes. The editor also gains auto-save functionality that writes all buffers after a configurable delay or when leaving insert mode, and prompts are now automatically closed when switching windows. Finally, snippet tabstops are validated and cleared when the document changes or focus is lost, and stale code action hints are cleared on selection changes.
helix-term/src/handlers · high confidence
New Rust syntax highlighting, indentation, and injection queries
This change introduces a comprehensive set of new Tree-sitter query files for the Rust language, significantly enhancing syntax highlighting, code indentation, and language injection capabilities. The new \highlights.scm\ provides detailed scoping for operators, paths, types, primitives, and documentation comments. The \indents.scm\ implements a robust indentation engine that correctly handles complex structures like multi-line assignments, match guards, and closure parameters. Additionally, \injections.scm\ adds support for highlighting SQL in \sqlx\ macros, regex in \Regex\ constructors, JSON in \json!\ macros, and Rust code in Markdown documentation blocks (via the new \markdown-rustdoc\ query). The \locals.scm\ improves variable tracking, distinguishing mutable variables and parameters, while \tags.scm\ and \textobjects.scm\ add definitions for navigation and text objects for functions, structs, enums, and more.
runtime/queries/rust · high confidence
New helix-parsec library for snippet parsing
The helix-parsec crate has been introduced to provide a set of parser-combinator functions for building parsers through functional composition. This library, which includes traits like \Parser\ and combinators such as \token\, \take\_until\, and \seq\, is used to optimize and revamp the parsing of LSP snippet text elements, replacing previous ad-hoc or external parsing logic with a dedicated, composable solution.
helix-parsec · high confidence
New shared query base for Ecma-based languages
A new \ecma\ query base has been introduced to provide shared syntax highlighting, indentation, local variable scoping, rainbow bracket matching, and text object definitions for JavaScript, TypeScript, and related languages. This change establishes an inheritance model where language-specific queries (such as the new private \\_javascript\ files for handling parameter tree deviations) inherit from this common \ecma\ layer, ensuring consistent behavior across Ecma-based languages while allowing for language-specific overrides.
runtime/queries/ecma · high confidence
Syntax highlighting for Astro files
Users now get syntax highlighting support for Astro files. The new \highlights.scm\ file defines visual styles for HTML tags, attributes, comments, and specific elements like links, bold, italic, and strikethrough text. Additionally, \injections.scm\ enables syntax highlighting for TypeScript within frontmatter blocks and TSX within interpolation blocks, inheriting from the HTML highlight rules.
runtime/queries/astro · high confidence
Architecture
Helix-term restructured into a modular library crate
The \helix-term\ source has been reorganized from a single monolithic file into a modular library crate. The codebase is now split into distinct modules for commands (including DAP, LSP, syntax, and typed commands), the UI compositor, configuration, event handling, job management, and keymaps. This refactoring introduces a dedicated event system (\events.rs\) to register and dispatch editor-wide events like mode switches and document changes, and a new handlers module (\handlers.rs\) to manage asynchronous background tasks such as auto-save, completion, and diagnostics. The \Context\ struct in \commands.rs\ has been expanded to include a \jobs\ field for managing these asynchronous operations, and the \lib.rs\ now exposes the new module structure along with shared utilities like binary detection and URL opening.
helix-term/src · high confidence
Inline helix-tui fork with initial widget implementations
The helix-tui crate is now an inlined fork of the upstream tui library, replacing the external dependency with local source code. This change introduces the foundational TUI widget layer, including the Block widget for rendering borders and titles, the Paragraph widget for displaying and wrapping text, and the Table widget for structured data display. The implementation also includes the reflow logic for text wrapping and truncation, establishing the core rendering primitives used by the editor's UI components.
helix-tui/src/widgets · high confidence
Introduce dedicated helix-dap-types crate for Debug Adapter Protocol types
The Debug Adapter Protocol (DAP) type definitions have been extracted into a new, dedicated \helix-dap-types\ crate. This change centralizes the serialization and deserialization logic for DAP structures—such as \Breakpoint\, \Source\, \DebuggerCapabilities\, and \ThreadId\—providing a clean, reusable interface for the debugger integration. Users benefit from a more modular architecture where DAP-specific data models are isolated, improving maintainability and clarity for the debugging subsystem.
helix-dap-types · high confidence
Introduce helix-core as the new text-editing foundation
Helix has been refactored to use a new core library (helix-core) that replaces the previous internal state and editing logic. This change introduces a new \State\ model that separates document state from view state, implements a new \Transaction\ and \ChangeSet\ system for handling edits, and adds support for auto-pairs, comment toggling, and case conversion. The core now also includes a new command-line parser for typable commands, a diagnostic provider system for LSP diagnostics, and a diff engine for comparing ropes. This refactoring is a foundational change that affects how the editor manages text, selections, and history.
helix-core/src · high confidence
New modular command structure for DAP, LSP, syntax, and typed commands
Helix reorganizes its command implementation by splitting the monolithic command logic into four dedicated modules: \dap.rs\ for debugger protocol interactions (including thread and breakpoint management), \lsp.rs\ for language server features (such as goto-definition, code actions, and diagnostics), \syntax.rs\ for tree-sitter based symbol picking, and \typed.rs\ for all user-facing typable commands (like \:open\, \:quit\, and \:write\). This change improves code maintainability and separation of concerns without altering the external user experience.
helix-term/src/commands · high confidence
Syntax configuration types moved to a dedicated module
The language and syntax configuration structs (such as \LanguageConfiguration\, \Configuration\, \RootMarkers\, and \FileType\) have been extracted from the main syntax module into a new \helix-core/src/syntax/config.rs\ file. This refactoring organizes the data structures that define how the editor handles file types, root markers, language servers, and formatting settings, without changing the external configuration format or user-facing behavior.
helix-core/src/syntax · high confidence
Behavioural changes
Add syntax highlighting for Rust format-args macros
This change introduces a new language query set for \rust-format-args-macro\ to improve syntax highlighting within Rust's \format\_args!\ macros. The new queries inherit from the standard Rust language but include a specific injection rule that treats string literals inside these macros as \rust-format-args\ content, ensuring that format specifiers and arguments are highlighted correctly. This addresses previous issues where code inside these macros was not properly highlighted.
runtime/queries/rust-format-args-macro · high confidence
Added missing license files for bundled themes
License files have been added for numerous bundled themes (including Akari, Ashen, Aura, Carbonfox, Dark Synthwave, Doom One, Everforest, Faded Prism, JetBrains Cyan Light, Kinda Nvim, Lapis Aquamarine, Modus Vivendi variants, Noctis, Poimandres, Quiet Light, and Serika Syntax) to ensure proper attribution and compliance with their respective open-source licenses.
runtime/themes/licenses · high confidence
Automated grammar building and Windows icon embedding in helix-term build
The helix-term build process now automatically fetches and compiles tree-sitter grammars during compilation (unless disabled by the HELIX\_DISABLE\_AUTO\_GRAMMAR\_BUILD environment variable) and embeds an application icon into the Windows executable. This change consolidates grammar handling into the build script, ensuring grammars are available at runtime without separate installation steps, and improves the Windows user experience by displaying a custom icon in the taskbar and file explorer.
helix-term · high confidence
Helix LSP client rewritten with Tokio and custom JSON-RPC
The helix-lsp module has been completely rewritten to use the Tokio async runtime instead of the previous implementation, significantly improving concurrency and stability. The custom JSON-RPC layer now supports both numeric and string request IDs, including floats that represent whole numbers, and accepts unknown fields to improve compatibility with non-conformant language servers. New capabilities include handling LSP file change notifications (DidChangeWatchedFiles) via a dedicated background task, supporting workspace folder management for multi-root projects, and implementing file operation filters (create, rename, delete) based on server capabilities. The transport layer now robustly handles malformed input, stream closures, and server stderr logging without panicking.
helix-lsp · high confidence
Highlight builtin diff configuration values in git-attributes
The git-attributes language query now includes syntax highlighting for builtin diff configuration values. When a diff attribute is set to a specific language (such as bash, python, or rust), that language name is highlighted as a builtin variable, improving readability of custom hunk header definitions in .gitattributes files.
runtime/queries/git-attributes · high confidence
Improved LSP hover and signature help UI with scrolling and multi-server support
The LSP hover popup now eagerly converts responses to Markdown for consistent rendering and supports cycling through results from multiple language servers using Alt+N/P keys. The signature help popup has been redesigned to match the hover UI, adding support for scrolling when content overflows the viewport and allowing users to cycle through multiple available signatures.
helix-term/src/ui/lsp · high confidence
Inline TUI backend with dual implementation (Termina and Crossterm)
The terminal backend logic has been inlined into the helix-tui crate, replacing the previous external dependency with a local implementation that supports two backends: the new 'Termina' backend (used on non-Windows platforms) and the 'Crossterm' backend (used on Windows). This change introduces support for advanced terminal features such as extended underlines, dynamic background color updates via OSC11, and the Kitty Keyboard Protocol, while also overriding the NO\_COLOR environment variable to ensure consistent color output.
helix-tui/src/backend · high confidence
JavaScript queries now inherit from shared ECMA base
The JavaScript language queries (highlights, indents, injections, locals, rainbows, tags, and textobjects) have been refactored to inherit from a shared ECMA base configuration. This change centralizes common logic for ECMA-based languages, ensuring JavaScript benefits from shared updates while maintaining specific overrides, such as the new highlighting for the \using\ keyword in highlights.scm.
runtime/queries/javascript · high confidence
New VCS abstraction layer with improved Git integration
Helix now includes a new \helix-vcs\ crate that provides a unified abstraction for version control systems, currently supporting Git. This introduces a \DiffProviderRegistry\ to manage diff providers and a new \DiffHandle\ for asynchronous, worker-based diff computation using the \imara\_diff\ library. The Git integration has been rewritten to use \gix\, enabling symlink resolution, proper handling of \core.autocrlf\ via the filter pipeline, and workspace trust controls that restrict untrusted repository-local config. Additionally, the changed-file picker now displays files marked with \git add --intent-to-add\.
helix-vcs/src · high confidence
New default keymap configuration and macro system
The default keybindings for Helix have been redefined in a new \default.rs\ file, establishing the standard mappings for Normal mode (including navigation, editing, selection, and LSP commands) and introducing helper macros in \macros.rs\ to simplify keymap definition. This change provides the foundational keybinding structure that users interact with by default.
helix-term/src/keymap · high confidence
Optimized diff computation with line caching and worker-based processing
The diff subsystem now uses a dedicated worker thread to perform diff calculations, preventing UI blocking during large file edits. A new line cache (\InternedRopeLines\) reuses allocations and optimizes line access to significantly speed up the diffing process. The system also introduces debouncing for diff events, with different timeout behaviors for synchronous and asynchronous contexts, and logs diff timeouts as info messages rather than warnings.
helix-vcs/src/diff · high confidence
Picker query parsing and preview highlighting improvements
The picker now supports a special query syntax using the '%' character to filter by specific columns (e.g., \%field1 value\), allowing users to target searches to particular data fields rather than just the primary column. Additionally, the preview highlighting logic has been refactored to use an asynchronous hook that detects the document's language before rendering, ensuring syntax highlighting is applied correctly. The dynamic query handler also skips the debounce timer for paste events, providing immediate feedback when pasting search terms.
helix-term/src/ui/picker · high confidence
Racket language queries now inherit from Scheme
The Racket language support now inherits its syntax highlighting, indentation, injection, and rainbow-bracket queries from the Scheme configuration. This change ensures that Racket files benefit from the same query definitions as Scheme, providing consistent behavior for these features without requiring separate, duplicate query files.
runtime/queries/racket · high confidence
Redesign of completion and picker UI components
The completion menu and picker system have been significantly refactored to improve rendering and interaction. The completion popup now supports previewing insertions in real-time (ghost transactions) and displays deprecated items with a crossed-out style. Picker components have been restructured to use a column-based model with integrated fuzzy matching via the Nucleo library, allowing for more flexible and performant filtering. Additionally, the Markdown renderer used in documentation popups now properly syntax-highlights code blocks, and the editor view rendering has been optimized to handle overlays and decorations more efficiently.
helix-term/src/ui · high confidence
Refactor completion, diagnostics, and DAP handlers into dedicated modules
The handler logic for completions, diagnostics, and the Debug Adapter Protocol (DAP) has been moved from the application layer into dedicated modules within helix-view. This introduces a CompletionHandler to track active completions and manage trigger events, a DiagnosticsHandler that debounces cursor-line diagnostic updates to reduce UI churn, and a DAP handler that centralizes debugger message processing and breakpoint management. These changes improve modularity and allow these specific view-level concerns to be managed independently.
helix-view/src/handlers · high confidence
TypeScript query files now inherit from the shared ECMA base
The TypeScript-specific query files (highlights, indents, injections, locals, tags, and textobjects) have been updated to inherit from the shared ECMA base configuration. This change centralizes common logic for JavaScript and TypeScript, ensuring that updates to the ECMA base are automatically applied to TypeScript. Additionally, a new \rainbows.scm\ file has been added to provide rainbow bracket highlighting for TypeScript-specific syntax elements such as type parameters, object types, and index signatures.
runtime/queries/typescript · high confidence
Updated documentation theme with Colibri support and logo favicon
The user guide's mdBook theme has been updated to include the 'Colibri' theme option in the theme switcher and to use the project logo as the site favicon (via a new favicon.svg file). This change improves the visual consistency of the documentation and provides users with an additional theming choice.
book/theme · high confidence
Vendor LSP types with URL handling and pull diagnostic support
Helix now includes a vendored copy of the \lsp-types\ crate (forked at v0.95.1) within the \helix-lsp-types\ package. This change replaces the external \url::Url\ dependency with a lightweight \String\ wrapper, which is sufficient for Helix's file-based URL requirements while adhering to RFC3986 standards. The update also adds type definitions for LSP 3.17 pull diagnostics, including the \identifier\ field for diagnostic providers and the \previousResultId\ parameter, and introduces support for LSP 3.16 file operations (create, rename, delete).
helix-lsp-types · high confidence
Version string now includes git hash and uses calendar versioning
The helix-loader build script now generates a version string that combines a calendar-based version (YY.MM or YY.MM.PATCH) with the first 8 characters of the current git commit hash. This change ensures that the reported version accurately reflects the specific build source, and it includes logic to re-run the build script if the git HEAD or its reference changes, preventing stale version information during development.
helix-loader · high confidence
Workspace trust gates local language configuration loading
Helix now requires explicit workspace trust to load \.helix/languages.toml\ files. In untrusted workspaces, only the global \languages.toml\ is applied, preventing potentially unsafe local language server configurations from executing. Users can grant trust via the \:workspace-trust\ command, and the editor warns when a local language config is skipped due to lack of trust.
helix-loader/src · high confidence
Test coverage
Added Windows path normalization tests; Added benchmark corpus for WordIndex testing; Added indent and highlight test corpus for 50+ languages; Added integration tests for command behavior; Added tests for Git symlink handling and diff base resolution; Added tests for indentation logic; Expanded integration test coverage for core editing features; Initial test suite for helix-tui core components; New integration test harness for helix-term; Updated encoding test fixtures for Big5, EUC-KR, GB18030, ISO-2022-JP, JIS0208, JIS0212, and Shift\_JIS.
Dependencies
Helix 25.7.1 release and workspace dependency consolidation
This update establishes the Helix 25.7.1 release version and consolidates the project's dependency management by migrating most crates to use a shared workspace dependency list. Key dependency upgrades include \rustix\ to 1.1, \toml\ to 1.1, \slotmap\ to 1.1.1, \bitflags\ to 2.12, and \unicode-segmentation\ to 1.13. The release also introduces \sonic-rs\ as a new dependency for performance-critical parsing tasks in the LSP and DAP clients, and updates \gix\ to 0.85.0 in the VCS module.
(dependencies) · high confidence
Housekeeping
Updated Helix editor tutorial content
The runtime tutor file has been updated with numerous improvements to the instructional text, including typo corrections, clarified instructions for key bindings and modes, and the addition of new lessons covering features like multi-cursor editing, splits, and match mode.
runtime · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 68 → 72 (+3.9)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.
Lenses
- Code Health 88 → 84 (-4.0)
- Architecture 94 → 94 (-0.7)
- Maturity 61 → 65 (+4.1)
- Readiness 69 → 74 (+4.4)
- Security 78 → 74 (-4.1)
- Event Sourcing 100 → 100 (+0.0)
- Accessibility 69 → 83 (+14.1)
- Performance 89 → 89 (+0.0)
Resolved (41)
- Duplicated block (10–11 lines × 2) (helix-term/src/ui/editor.rs)
- Duplicated block (11 lines × 2) (helix-term/src/commands.rs)
- Duplicated block (11 lines × 3) (helix-term/src/commands/typed.rs)
- Duplicated block (12–13 lines × 2) (helix-core/src/movement.rs)
- Duplicated block (15 lines × 2) (helix-term/src/health.rs)
- Duplicated block (15–16 lines × 2) (helix-term/src/commands.rs)
- Duplicated block (16–18 lines × 2) (helix-loader/src/grammar.rs)
- Duplicated block (5 lines × 2) (helix-view/src/handlers/lsp.rs)
- Duplicated block (5 lines × 3) (helix-term/src/commands.rs)
- Duplicated block (7 lines × 2) (helix-term/src/commands.rs)
- Duplicated block (7 lines × 2) (helix-term/src/commands.rs)
- Duplicated block (7 lines × 2) (helix-term/src/commands/dap.rs)
- Duplicated block (7 lines × 2) (helix-term/src/ui/prompt.rs)
- Duplicated block (8 lines × 2) (helix-loader/src/grammar.rs)
- Duplicated block (8 lines × 2) (helix-term/src/commands.rs)
- Duplicated block (8 lines × 2) (helix-term/src/commands.rs)
- Duplicated block (8–9 lines × 2) (helix-term/src/commands.rs)
- Duplicated block (9 lines × 2) (helix-term/src/handlers/document_colors.rs)
- Duplicated block (9–12 lines × 2) (helix-term/src/commands/typed.rs)
- Hotspot: helix-term/src/application.rs (helix-term/src/application.rs)
- …and 21 more
New (173)
- Duplicated block (10 lines × 2) (helix-term/src/commands.rs)
- Duplicated block (10 lines × 2) (helix-term/src/commands/typed.rs)
- Duplicated block (10 lines × 2) (helix-term/src/handlers/auto_save.rs)
- Duplicated block (10–11 lines × 2) (helix-term/src/ui/editor.rs)
- Duplicated block (11 lines × 2) (helix-term/src/commands.rs)
- Duplicated block (11 lines × 2) (helix-term/src/commands.rs)
- Duplicated block (11 lines × 3) (helix-term/src/commands/typed.rs)
- Duplicated block (11–12 lines × 2) (helix-term/src/commands/dap.rs)
- Duplicated block (12–13 lines × 2) (helix-core/src/movement.rs)
- Duplicated block (14 lines × 2) (helix-term/src/ui/menu.rs)
- Duplicated block (15 lines × 2) (helix-term/src/health.rs)
- Duplicated block (15–16 lines × 2) (helix-term/src/commands.rs)
- Duplicated block (15–16 lines × 2) (helix-term/src/commands.rs)
- Duplicated block (16–18 lines × 2) (helix-loader/src/grammar.rs)
- Duplicated block (5 lines × 2) (helix-term/src/commands.rs)
- Duplicated block (5 lines × 2) (helix-view/src/handlers/lsp.rs)
- Duplicated block (5 lines × 3) (helix-term/src/commands.rs)
- Duplicated block (6 lines × 2) (helix-term/src/commands.rs)
- Duplicated block (6 lines × 2) (helix-term/src/commands.rs)
- Duplicated block (7 lines × 2) (helix-lsp/src/lib.rs)
- …and 153 more
Changes since last survey
- 15 commits — 13 feature/other, 2 fixes
By area
- helix-core/src — 6 commits
- helix-term/src — 6 commits
- (root) — 2 commits
- helix-loader/src — 1 commit
Notable commits
- fix: fix: Extend the previous fix to properly fix edge cases
- fix: fix: fix treesitter_indent_for_pos with CRLF
- change: Make :format fall back to fixing the indentation if there is no formatter
- change: Reimplement :reflow with a simple greedy implementation, drop textwrap
- change: Store the history revision with each jump instead of syncing views
- change: cargo fmt
- change: fix doc lint
- change: fix: last line of block indentation for whitespace sensitive languages
- change: indent: reuse query_indents
- change: lsp: don't use current!() in select_references_to_symbol_under_cursor
- change: lsp: simplify resolving code actions on save and apply them together
- change: minor: simplify closed document checks
- change: nix: Improvements to flake and built package
- change: ui: extract surface_row helper
- change: workspace trust: remove unused code and the duplicated trust level enum
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
helix-editor/helix was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit a714a818a3a4f6dd5aad3b003a78692f90a1703f — the exact code this score is about.
- Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-36d4cd83012f.