helix-editor/helix

This release delivers a massive expansion of language support, adding syntax highlighting, indentation, and text objects for over 60 new languages and file types, including Go, C\#, Zig, and PowerShell. Core editor features are significantly enhanced with a new snippet system, inline diagnostics, path completion, and a dedicated Debug Adapter Protocol (DAP) client. The architecture is heavily refactored, introducing new crates for terminal UI, events, and VCS integration, while also enforcing workspace trust for improved security.

New tree-sitter-based query files are introduced for Bash scripts, enabling syntax highlighting, indentation, and code navigation features. The changes add highlight rules for Bash tokens (e.g., keywords, operators, strings, comments), define indentation and outdentation rules for control structures and function blocks, and configure injections for embedded languages like Awk, jq, and regex within Bash strings. Additionally, local variable scopes, function tags, and text objects for Bash constructs are established.

runtime/queries/bash · high confidence

Users can now open and edit Cap'n Proto (.capnp) files with full syntax highlighting, indentation, and local variable support. The new query files define how the editor highlights keywords, types, and literals, and how the language server identifies scopes and references for the Cap'n Proto format.

runtime/queries/capnp · high confidence

Introduces new syntax highlighting rules for the CodeQL language, including keywords, types, operators, and comments, and adds text object definitions for navigating classes, predicates, and comments. This enables proper visual styling and structural navigation for CodeQL files.

runtime/queries/codeql · high confidence

Added runtime query files for the Concerto modeling language, enabling syntax highlighting, indentation rules, and text object navigation in the editor. This includes definitions for keywords, types, and field names in highlights.scm, indentation scopes in indents.scm, local scope and reference tracking in locals.scm, and class/parameter text objects in textobjects.scm.

(repo-wide) · high confidence

Added new query files for the D programming language, enabling syntax highlighting, indentation rules, local variable scoping, and text object definitions. This allows the editor to correctly highlight D code, indent blocks like functions and classes, and identify local variables and parameters for features like go-to-definition and refactoring.

runtime/queries/d · high confidence

Users gain comprehensive Elixir language support in the editor. Syntax highlighting is provided for all Elixir constructs, including atoms, strings, sigils, and function calls. Indentation rules are defined for blocks, maps, lists, and tuples, with proper outdenting for closing keywords. Text objects allow selection of function heads, modules, and comments. Additionally, code injection is enabled for Markdown in documentation comments, and for HEEx, JSON, and Regex within sigils.

(repo-wide) · high confidence

Added syntax highlighting, code injection, local variable tracking, and rainbow bracket support for the F\# programming language. This enables proper visual highlighting of F\# code in the editor, including comments, types, functions, and namespaces, as well as correct local scope and reference detection.

runtime/queries/fsharp · high confidence

Users can now use Fortran with syntax highlighting, code folding, and automatic indentation. New query files define how the editor recognizes Fortran constructs: \folds.scm\ enables folding for blocks like \if\, \do\, and \subroutine\; \indents.scm\ configures indentation for modules, programs, and control flow; \highlights.scm\ provides colorization for keywords, types, and comments; and \injections.scm\ handles comment injection.

runtime/queries/fortran · high confidence

Introduced comprehensive syntax highlighting, indentation, text objects, and injection rules for the Go language. This includes support for Go's format strings (e.g., \fmt.Printf\), regex patterns, and markdown in documentation comments. The changes also define how Go code is indented, how local variables and functions are scoped, and how specific Go constructs are highlighted or tagged for navigation.

runtime/queries/go, runtime/queries/msbuild · high confidence

Added syntax highlighting and HTML injection support for the Graphviz Dot language. This introduces new highlight queries for identifiers, keywords, strings, numbers, operators, delimiters, brackets, subgraphs, attributes, comments, and preprocessor directives, enabling proper visual distinction of Dot file components in the editor.

runtime/queries/dot · high confidence

Added new query files for the Groovy language, enabling syntax highlighting, code folding, local variable scoping, and rainbow bracket support. This includes definitions for keywords, operators, types, and structural elements to improve the editing experience for Groovy code.

runtime/queries/groovy · high confidence

A new interactive tutorial for the Helix text editor has been added to the runtime files, guiding users through basic cursor movement, insertion modes, deletion, and file saving.

runtime · high confidence

Added new query files for the Lean programming language, enabling syntax highlighting, code folding, and local scope resolution. The changes include definitions for folding namespaces, sections, and declarations; highlighting for keywords, operators, and types; and injection rules for comments. This provides basic language support for Lean users.

runtime/queries/lean · high confidence

Users on Linux desktop environments will now see Helix properly integrated into application menus and file managers. This change introduces AppStream metadata (Helix.appdata.xml) which provides a description, screenshots, and release history for software centers. A desktop entry file (Helix.desktop) is added with translations in multiple languages and the ConsoleOnly category to ensure it appears in the correct section of the menu. A launcher script (hx\_launcher.sh) is included to set the runtime path, and a symlink to the themes directory is created to support the desktop environment.

contrib · high confidence

Added comprehensive syntax highlighting, indentation, folding, and textobject queries for the Lua programming language, including support for the new \global\ keyword in Lua 5.5. Additionally, introduced a new \lua-format-string\ query set to highlight \string.format\ templates, and added a \luap\ (Lua pattern) query set to highlight Lua pattern language syntax.

runtime/queries/lua · high confidence

Users can now use syntax highlighting and indentation for the Move programming language. This change introduces new query files (highlights.scm and indents.scm) that define how Move code is visually formatted, including keywords, literals, and structural elements.

runtime/queries/move · high confidence

Added new syntax highlighting and injection queries for Nginx configuration files. The changes introduce \highlights.scm\ to define token types for Nginx directives, variables, strings, and comments, and \injections.scm\ to enable Lua and regex language injection within Nginx blocks.

runtime/queries/nginx · high confidence

Added runtime query files for Nix, enabling syntax highlighting, code folding, indentation, text objects, and language injections for embedded scripts (e.g., Bash, Python, JSON, TOML). This includes defining scopes for brackets, function parameters, and variable references, as well as highlighting rules for builtins and higher-order functions.

runtime/queries/nix · high confidence

Added new syntax highlighting, local scope, tag, and injection queries for PHP-only files. This enables proper code navigation, syntax highlighting, and code intelligence features for PHP files that are not part of a broader multi-language query set.

runtime/queries/php-only · high confidence

Added new syntax highlighting, indentation, injection, and textobject query files for PKGBUILD, inheriting from Bash. This enables basic editing features for PKGBUILD files in the editor.

runtime/queries/pkgbuild · high confidence

Added syntax highlighting, indentation, and folding support for the PTX assembly language. This includes defining query files for highlights (covering comments, directives, keywords, types, instructions, and literals), indentation rules for function bodies and entry declarations, and folding rules for the same structures.

(repo-wide) · high confidence

Users can now use Pkl files with proper syntax highlighting, indentation, and code injection. The new query files (highlights.scm, indents.scm, injections.scm) define how the Pkl language is parsed and displayed, including keywords, operators, literals, and comments.

runtime/queries/pkl · high confidence

Introduces syntax highlighting and textobject queries for the Prisma language. The changes add a new \highlights.scm\ file that defines semantic tokens for Prisma elements, including models, enums, generators, and views, while ensuring null literals are consistently highlighted as built-in constants. Additionally, a new \textobjects.scm\ file is added to support textobject navigation for models, call expressions, column declarations, arrays, and comments.

runtime/queries/ocaml, runtime/queries/prisma, runtime/queries/rescript · high confidence

The SQL language support received new query files that enable syntax highlighting, rainbow bracket coloring, and textobject navigation. Specifically, \highlights.scm\ defines highlight groups for SQL keywords (such as SELECT, FROM, WHERE), functions, variables, and literals. \rainbows.scm\ configures rainbow bracket coloring for expressions, subqueries, and function arguments. \textobjects.scm\ adds textobject queries for SQL comments. These changes improve the visual feedback and editing experience for SQL files.

runtime/queries/sql · high confidence

Added comprehensive syntax highlighting, indentation, and text-object queries for the Scheme programming language. This includes \highlights.scm\ for coloring numbers, strings, functions, and special forms; \indents.scm\ to handle Scheme's S-expression indentation rules; \locals.scm\ to define variable scopes and references; \tags.scm\ to identify function and constant definitions; \textobjects.scm\ for comment selection; \injections.scm\ for comment injection; and \rainbows.scm\ for bracket matching. This enables full language support for Scheme files in the editor.

runtime/queries/hcl, runtime/queries/scheme · high confidence

Added Tree-sitter queries for the StrictDoc markup language, enabling syntax highlighting, code folding, and symbol navigation (headings, requirements, and grammar fields) in editors that support Tree-sitter. This includes highlight rules for keywords and metadata, injection of RST for inline text, and tag definitions for document structure.

runtime/queries/strictdoc · high confidence

New query files are introduced for the TSX language, including highlights, indents, injections, locals, rainbows, tags, and textobjects. These files inherit from existing \_jsx, \_typescript, and ecma configurations, ensuring that TSX files receive consistent syntax highlighting, indentation rules, and text object support aligned with JavaScript, TypeScript, and JSX.

(repo-wide) · medium confidence

Added syntax highlighting rules for Twig templates, mapping identifiers, variables, strings, operators, and control structures to appropriate highlight groups. Additionally, configured the editor to inject HTML syntax highlighting within Twig content blocks, enabling proper syntax highlighting for embedded HTML.

runtime/queries/twig · high confidence

New query files are added for the Typst language, enabling syntax highlighting (highlights.scm), code navigation (tags.scm), and text object selection (textobjects.scm) within the editor. The highlights file defines keywords, operators, and markup elements; the tags file maps headings and labels to section and function definitions; and the textobjects file allows selection of function and parameter scopes.

runtime/queries/typst · high confidence

Introduces new syntax highlighting, indentation, text objects, and tag queries for the Julia programming language. This includes specific handling for Julia's function definitions, constructors, and type system, ensuring that constructors are not incorrectly highlighted as functions and that markdown strings are properly injected for syntax highlighting.

runtime/queries/julia · high confidence

This change introduces a complete set of tree-sitter based queries for the Ruby language, replacing previous or missing definitions. It provides syntax highlighting for operators, literals, identifiers, and keywords; enables code folding and navigation via tags; defines text objects for classes, methods, blocks, and arrays; and allows injection of Bash, ERB, and GraphQL into Ruby heredocs and string literals. Users will see improved syntax highlighting, better code navigation, and enhanced editing capabilities for Ruby files.

runtime/queries/ruby · high confidence

Added new TOML syntax query files (highlights, indents, injections, rainbows, tags, and textobjects) to the runtime/queries/toml directory. This introduces syntax highlighting for table headers, keys, literals, and punctuation; enables proper indentation for arrays and inline tables; provides rainbow bracket matching for tables and arrays; defines tags for table sections; and adds text objects for pairs, arrays, and comments. These changes improve the editing experience for TOML files by enabling better visual feedback, navigation, and code structure awareness.

runtime/queries/toml · high confidence

Users can now see syntax-highlighted code and code folding for SuperCollider files. This change introduces new query files (folds.scm and highlights.scm) that define how SuperCollider's syntax elements—such as comments, variables, functions, operators, and control structures—are visually distinguished in the editor.

runtime/queries/supercollider · high confidence

Users can now have their BitBake files syntax-highlighted and have embedded Python and Bash code correctly injected for highlighting. This includes defining keywords for variables, functions, and control flow, as well as injecting Python and Bash syntax into the appropriate code blocks within BitBake recipes.

runtime/queries/bitbake · high confidence

New syntax highlighting and injection rules for inline Markdown elements are introduced. Inline Markdown constructs such as code spans, links, images, emphasis, and escapes are now highlighted with appropriate tree-sitter queries. Additionally, HTML tags within inline Markdown are injected as HTML content, and LaTeX blocks are injected as LaTeX, enabling proper syntax highlighting for these embedded languages within Markdown files.

runtime/queries/markdoc, runtime/queries/markdown.inline · high confidence

New syntax highlighting and tag queries for reStructuredText (RST) documents have been added. The \highlights.scm\ file defines visual styles for RST elements including headings, links, lists, bold/italic text, directives, fields, and raw text. The \tags.scm\ file enables navigation to RST sections using the \@definition.section\ tag.

runtime/queries/rst · high confidence

Users can now benefit from command-line autocompletion in Bash, Elvish, Fish, Nushell, and Zsh. The scripts provide tab-completion for Helix flags such as --strict, --vsplit, --hsplit, --config, --log, --health, and --grammar, and dynamically suggest available languages for the --health command.

contrib/completion · high confidence

The editor now supports LSP/VSCode-style snippets, allowing users to insert templated text with tabstops, placeholders, choices, and variables. This change introduces the core parsing, elaboration, and rendering logic for snippets, including handling of placeholder text for the \$0\ tabstop.

helix-core/src/snippets · high confidence

Introduces comprehensive syntax highlighting, code folding, indentation, text objects, and local variable scoping for the \just\ build file format. This enables users to edit \justfile\ with proper syntax-aware features, including bash or PowerShell injection for recipe bodies, regex highlighting for patterns, and navigation around recipes, functions, and parameters.

runtime/queries/just · high confidence

Users can now increment or decrement selected integers (including binary, octal, and hexadecimal formats) and date/time strings. The new \increment\ module in \helix-core\ provides \integer\ and \date\_time\ functions that parse the selected text, perform the arithmetic or date adjustment, and return the formatted result. This enables direct editing of numbers and timestamps within the editor.

helix-core/src/increment · high confidence

Users will now see syntax highlighting for git-rebase files, with commands like 'pick', 'edit', and 'exec' distinguished by color. Additionally, the 'exec' and 'x' commands will have their arguments highlighted as bash code, allowing for better readability of shell commands within the rebase script.

runtime/queries/git-rebase · high confidence

New query files (folds, highlights, injections, rainbows, textobjects) are added for the Blade template language. This enables syntax highlighting for Blade directives, PHP code injection, and support for Livewire/Alpine.js attributes, as well as code folding for directives and brackets.

runtime/queries/blade · high confidence

Users editing Dockerfiles will now see syntax highlighting for all standard Dockerfile instructions (such as FROM, RUN, CMD, etc.), with specific styling for image tags, digests, strings, and heredoc blocks. Additionally, the content of RUN and COPY instructions that use heredocs will be injected as Bash code, enabling proper syntax highlighting and potentially other language-specific features within those blocks.

runtime/queries/dockerfile · high confidence

Added syntax highlighting and code injection support for EJS and ERB templates. For EJS, new highlight queries define keywords for template delimiters (e.g., \\<%\, \\<%=\) and comments, while injection queries enable HTML and JavaScript syntax highlighting within those templates. ERB templates inherit the EJS highlighting rules and receive injection queries that enable HTML and Ruby syntax highlighting within the template code.

runtime/queries/ejs · high confidence

New query files have been added to the \runtime/queries/gitlab-ci\ directory, establishing a dedicated language mode for GitLab CI configuration files. This includes syntax highlighting rules that distinguish GitLab-specific keywords (such as \variables\, \stages\, and \default\) from standard YAML structures, as well as text objects and tags for navigation and code intelligence. Additionally, the configuration enables code injection for shell scripts within \script\, \before\_script\, and \after\_script\ fields, and treats \regex\ and \coverage\ values as regular expressions, providing syntax-aware editing for these common GitLab CI patterns.

runtime/queries/astro, runtime/queries/gitlab-ci, runtime/queries/godot-resource · high confidence

Users can now edit literate Haskell files with proper syntax highlighting and code injection. The new highlights.scm file defines rules to highlight bird-track markers, LaTeX delimiters, and Markdown delimiters, while treating normal prose as unhighlighted. The injections.scm file configures the editor to parse Haskell code within bird-style lines, LaTeX code blocks, and Markdown code blocks, enabling correct syntax highlighting and language features for these embedded code sections.

runtime/queries/edoc, runtime/queries/haskell-literate, runtime/queries/prql · medium confidence

KDL files now receive full editor support, including syntax highlighting for comments, strings, keywords, and brackets, as well as text objects for navigating nodes, types, and comments. The editor also injects language-specific highlighting for regex patterns in window rules and fish shell scripts in spawn actions, while providing proper indentation and rainbow bracket matching for KDL structures.

runtime/queries/kdl · high confidence

New query files for MoonBit have been added to the runtime, enabling syntax highlighting, indentation, local variable tracking, tag definitions, and text object selection for the language. This allows editors to properly highlight MoonBit code, understand its structure, and support features like 'select function' or 'go to definition' for MoonBit files.

runtime/queries/moonbit · high confidence

Added new query files for the Ripple framework, enabling syntax highlighting, code folding, local variable tracking, and symbol navigation for components, functions, classes, and JSX elements.

runtime/queries/ripple · high confidence

New query files have been added to the runtime/queries/glsl directory, including highlights, folds, indents, injections, locals, rainbows, tags, and textobjects. These changes provide syntax highlighting for GLSL-specific keywords (such as uniform, layout, precision), enable code folding for GLSL blocks, and support indentation and local variable detection, improving the editing experience for GLSL shader files.

runtime/queries/glsl, runtime/queries/nu · high confidence

Added syntax highlighting rules for Taskwarrior files, mapping comments, datetime, identifiers, and keywords to appropriate highlight groups. Additionally, enabled comment injection for Taskwarrior files, allowing comments within those files to be highlighted as comments.

runtime/queries/ledger, runtime/queries/task · medium confidence

Users can now benefit from syntax highlighting and comment injection for C3 source files. This change introduces new highlight queries that map C3-specific keywords (such as \fn\, \macro\, \import\, \struct\, and various \$\-prefixed directives) to appropriate text scopes, and adds injection rules to treat C3 comments as 'comment' language for improved rendering.

runtime/queries/c3 · high confidence

Added syntax highlighting and diff injection for jjdescription files. The new highlights.scm file defines highlighting rules for text, filepaths, comments, and diff change types (additions, deletions, modifications, copies, and renames). The injections.scm file enables diff language injection for the scissors\_inner node, allowing proper syntax highlighting within diff blocks in jjdescription files.

runtime/queries/jjdescription · high confidence

Users can now view Smali files with syntax highlighting, including support for types, methods, fields, variables, parameters, labels, operators, keywords, and literals. The new queries define how Smali code is folded, indented, and injected for comments, improving the editing experience for this language.

runtime/queries/smali · high confidence

Added new query files (folds, highlights, injections, locals) for the Thrift language, enabling syntax highlighting, code folding, and local variable tracking for .thrift files.

runtime/queries/thrift · high confidence

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 injections for Vim script files.

runtime/queries/vim · high confidence

Users can now edit Cpon files with proper syntax highlighting and indentation support. The new highlight queries define keywords, strings, and punctuation for Cpon, while the indentation rules ensure correct nesting for maps, arrays, and other structures.

runtime/queries/cpon, runtime/queries/styx, runtime/queries/tolk · high confidence

Added support for Cylc configuration files, including syntax highlighting, indentation rules, text objects, and code injections for bash scripts within specific settings. This enables proper visual formatting and editing capabilities for Cylc files in the editor.

runtime/queries/cylc · high confidence

Users can now get syntax highlighting, indentation, and text-object support for LLVM Machine Intermediate Representation (MIR) files, as well as YAML files. This includes specific highlighting for MIR keywords, types, and variables, along with proper indentation rules for basic blocks and labels.

runtime/queries/llvm-mir · high confidence

Users can now edit Puppet configuration files with proper syntax highlighting and auto-indentation. This change introduces highlight queries for Puppet keywords, types, functions, and operators, as well as indentation rules for blocks and control structures, enabling a better editing experience for Puppet manifests.

runtime/queries/puppet, runtime/queries/tql · high confidence

Users can now get syntax highlighting and proper indentation for Robot Framework (.robot) files. This change adds new highlight and indent query files for the 'robot' language, mapping elements like comments, keywords, variables, and control structures (FOR, WHILE, IF, TRY) to appropriate highlight groups, and defines indentation rules for test cases, keywords, and control blocks.

runtime/queries/robot · high confidence

New tree-sitter query files are added for the Yuck language (used by Eww), providing syntax highlighting, indentation, and rainbow bracket support. This enables proper visual formatting for Yuck configuration files, including highlighting for operators, literals, functions, tags, and built-in widgets.

runtime/queries/yuck · high confidence

Added support for the linker script language, including syntax highlighting rules for identifiers, operators, keywords, and literals, as well as indentation and comment injection queries. This enables proper visual formatting and structure recognition for linker scripts in the editor.

runtime/queries/ld · high confidence

New query files are added for the RON language, providing syntax highlighting (for structs, literals, comments, and punctuation), indentation rules for nested structures, rainbow bracket highlighting, and tag definitions for struct entries.

runtime/queries/ron · high confidence

Added new syntax highlighting and indentation rules for WIT (WebAssembly Interface Types) files. This includes highlighting for comments, types, functions, variables, constants, built-in types, macros, punctuation, keywords, and control flow, as well as indentation rules for various WIT item types.

runtime/queries/wit · high confidence

This change introduces the initial support for the Nim language by adding new query files for syntax highlighting, indentation, text objects, and rainbow brackets. The highlights file defines tokens for comments, literals, operators, control flow, and type declarations, while the indents file configures block and statement indentation for control flow and declarations. This enables proper visual formatting and navigation for Nim code.

runtime/queries/koka, runtime/queries/nim · high confidence

Users can now get syntax highlighting, indentation, and other language features for GJS and GTS files. This adds new query files for the \gjs\ and \gts\ file extensions, inheriting from existing JavaScript/TypeScript and GJS/TS base queries to provide consistent editing experiences for these template languages.

runtime/queries/gjs, runtime/queries/gts · high confidence

Added new syntax support for Cross-CLI configuration files (cross-config). This includes highlight rules, text objects, and rainbow brackets that inherit from TOML, as well as an injection that enables bash syntax highlighting for the 'pre-build' array values, improving code navigation and readability for these specific config files.

runtime/queries/cross-config · high confidence

Django template syntax is now supported for syntax highlighting and injection. This includes highlighting for comments, brackets, variables, filters, keywords, operators, numbers, booleans, and strings, as well as injecting HTML syntax highlighting for content within Django templates.

runtime/queries/htmldjango · high confidence

New query files have been added to support syntax highlighting and language injection for Go templates (gotmpl). This includes highlighting rules for identifiers, function calls, operators, built-in functions, delimiters, control flow keywords, literals, and comments, as well as an injection rule that treats Go template text as HTML.

runtime/queries/gotmpl · high confidence

Added syntax highlighting and code injection support for the SpiceDB schema language and CEL (Common Expression Language). This enables proper visual highlighting of schema elements like definitions, relations, and operators, as well as correct syntax highlighting for CEL expressions embedded within SpiceDB caveats.

runtime/queries/spicedb · high confidence

Users can now edit and navigate Woodpecker CI configuration files with full syntax support. This adds specific highlighting for YAML structure and key-value pairs, defines text objects for selecting 'steps' blocks, and injects Bash syntax highlighting for 'commands' and 'entrypoint' fields, enabling proper code folding and navigation within CI workflow definitions.

runtime/queries/woodpecker-ci · high confidence

New highlight and injection queries for embedded Perl are added to the runtime/queries/embedded-perl directory. This enables proper syntax highlighting for Perl code embedded within other files, with Perl code injected for highlighting and HTML for the surrounding text.

runtime/queries/embedded-perl · high confidence

Users editing git-cliff configuration files will now see proper syntax highlighting and language injection. The editor recognizes the TOML-based config format, inheriting TOML highlighting rules, and provides specific injection for template strings (Terraform/templating), regular expressions, and bash scripts within the configuration file.

runtime/queries/git-cliff-config · high confidence

New highlight and injection query files are added for the git-ignore language, enabling syntax highlighting for patterns, operators, and comments, as well as injecting comment syntax highlighting within .gitignore files.

runtime/queries/git-ignore · high confidence

New highlight and injection query files for the Ghostty configuration language have been added to the runtime. The highlights.scm file defines syntax rules for various configuration elements including comments, keys, values, operators, and special keywords, while the injections.scm file enables comment injection. This provides basic syntax highlighting for Ghostty configuration files in the editor.

runtime/queries/ghostty · high confidence

Users can now edit Vento template files with proper syntax highlighting and code injection. The new highlights.scm file defines keywords, comments, and template delimiters ({{, {{-, }}, -}}) for Vento, while injections.scm configures content blocks to be treated as HTML and code blocks as JavaScript, enabling accurate syntax coloring and language injection within Vento templates.

runtime/queries/vento · high confidence

New syntax highlighting rules have been added for Markdown, covering headings, code blocks, links, lists, and quotes. Additionally, language injection is now supported for fenced code blocks, HTML blocks, pipe tables, and front-matter metadata (YAML/TOML), enabling syntax-aware editing within those embedded contexts.

runtime/queries/markdown · high confidence

Users will now see syntax highlighting for Glimmer templates, including distinct colors for HTML tags, Glimmer components, variables, helpers, and control flow keywords. Additionally, JavaScript and CSS code within script and style elements will be highlighted using the respective language modes.

runtime/queries/glimmer · high confidence

Users can now edit Crystal source code with full syntax highlighting, indentation, and navigation support. This change introduces new query files (highlights, indents, injections, locals, rainbows, tags, and textobjects) for the Crystal language, enabling features like keyword and literal coloring, block and class text-object selection, and function/class tagging in the language server.

runtime/queries/crystal, runtime/queries/wgsl · high confidence

New syntax highlighting and local scope queries for the Circom language have been added. The highlights.scm file defines how identifiers, keywords, operators, and other language constructs are colored in the editor, while locals.scm establishes scoping rules for functions, templates, and component definitions, enabling features like variable reference tracking.

runtime/queries/circom · high confidence

Added syntax highlighting and local variable scoping for the TLA+ language, including support for PlusCal. The new \highlights.scm\ file defines keyword, literal, namespace, constant, parameter, function, and operator captures for TLA+ and PlusCal syntax. The new \locals.scm\ file defines scopes and definitions for TLA+ modules, operators, proofs, and PlusCal algorithms, procedures, and macros, enabling IDE features like go-to-definition and variable highlighting.

runtime/queries/tlaplus · high confidence

Users will now see syntax highlighting and local variable resolution for Tera template files. This change introduces grammar queries that define how Tera's variables, control flow keywords (like if, for, include), functions, and filters are highlighted in the editor. It also enables the editor to recognize local variable definitions and references within Tera templates, improving code navigation and autocompletion for template logic.

runtime/queries/tera · high confidence

Users can now benefit from syntax highlighting and local variable tracking for the Fennel programming language. This update introduces new query files (highlights.scm, locals.scm, and rainbows.scm) that define how Fennel code is visually categorized, including keywords, functions, variables, and control structures, as well as how local scopes and definitions are identified for navigation and refactoring tools.

(repo-wide) · high confidence

The editor now provides syntax highlighting and local variable navigation for the P formal modeling language. This includes highlighting for P-specific keywords (such as 'spec', 'machine', 'invariant'), built-in types, functions, and operators, as well as proper scoping for variables and parameters within P code blocks.

runtime/queries/p · high confidence

Users can now open Metamath (.mm) files with full syntax highlighting, local variable resolution, and tag-based navigation. The new query files define how keywords, types, labels, and proofs are highlighted and indexed, enabling features like go-to-definition for axioms, theorems, and hypotheses, as well as symbol completion and outline views for Metamath proofs.

runtime/queries/metamath · high confidence

New syntax queries for the Inko language have been added to the runtime/queries/inko directory. This includes highlights.scm for syntax coloring, indents.scm for indentation rules, injections.scm for comment injection, locals.scm for variable scope, tags.scm for symbol definitions, and textobjects.scm for text object selection. These changes enable proper code highlighting, indentation, and navigation features for Inko source files.

runtime/queries/inko · high confidence

New query files have been added to the \runtime/queries/docker-bake\ directory, introducing support for the \docker-bake\ language. This includes \folds.scm\, \highlights.scm\, \indents.scm\, \rainbows.scm\, \tags.scm\, and \textobjects.scm\, all of which inherit from \hcl\. The \injections.scm\ file specifically enables syntax highlighting for inline Dockerfiles and regex patterns within the bake configuration, while \tags.scm\ defines structure for targets, groups, and variables.

runtime/queries/docker-bake · high confidence

Users can now get syntax highlighting, indentation, and local variable tracking for R and R Markdown files. R files receive specific highlight queries for identifiers, operators, literals, and functions, while R Markdown files inherit the base Markdown queries to support embedded code blocks.

runtime/queries/r · high confidence

Added support for the Teal programming language by introducing new syntax highlighting and scope queries. The changes include \folds.scm\ to define foldable regions for statements and declarations, \highlights.scm\ to apply semantic token types (such as keywords, types, and variables) to Teal source code, and \locals.scm\ to define local variable scopes and references. These additions enable proper code folding, syntax highlighting, and variable scoping for Teal files.

runtime/queries/teal · high confidence

Users can now benefit from syntax highlighting and local variable scoping for OpenSCAD files. This change introduces highlight queries that distinguish keywords, operators, built-in functions, and comments, while the locals query defines scopes for functions, modules, and loops, enabling features like go-to-definition and reference counting for OpenSCAD code.

runtime/queries/openscad · high confidence

Added support for the Hyprland configuration language (hyprlang) in the editor. This includes syntax highlighting for keywords, variables, strings, and special characters, as well as structural tags for sections and variables to enable features like code navigation and indentation.

runtime/queries/hyprlang · high confidence

Users can now use SlightLisp as a supported language in the editor. This change introduces syntax highlighting rules (highlights.scm) and tag definitions (tags.scm) for SlightLisp, enabling features like keyword, function, and variable highlighting, as well as code navigation for definitions.

runtime/queries/slisp · high confidence

New syntax highlighting and tag definitions have been added for INI files, enabling features like code navigation and colorized text for sections, settings, and comments. The systemd configuration files now inherit these same highlighting and tagging rules, ensuring consistent visual treatment and navigation support across both file types.

runtime/queries/ini · high confidence

Syntax highlighting and template injection for Glimmer templates in GJS/GTS files are now supported. This adds specific query rules to highlight Glimmer opening and closing tags as built-in constants, and enables the injection of Glimmer template syntax within JavaScript template strings, including those wrapped by the 'hbs' helper.

_runtime/queries/\gjs · high confidence

Users can now see Solidity code with proper syntax highlighting, including keywords, types, functions, and literals, as well as improved text object queries for navigating and selecting code blocks like functions, constructors, and parameters.

runtime/queries/solidity · high confidence

Users can now get syntax highlighting and text-object navigation for Earthfile (the build tool configuration format). This change introduces highlight queries that color keywords (such as BUILD, RUN, COPY), strings, variables, and comments, as well as indent rules for targets. It also adds textobject queries to allow selecting or navigating around targets and blocks within an Earthfile.

(repo-wide) · high confidence

Users can now use syntax highlighting and text object selection for GNU Assembler (gas) files. This change introduces new query files (highlights.scm, injections.scm, textobjects.scm) that define how gas source code is parsed and styled, including keywords, functions, registers, and comments.

runtime/queries/gas · high confidence

New query files (highlights, indents, injections, locals, textobjects) are added for the LLVM IR language, enabling syntax highlighting, indentation, and text-object selection for LLVM IR files.

runtime/queries/llvm · high confidence

Users can now get syntax highlighting and text object support for NASM (Netwide Assembler) files. This includes highlighting for comments, labels, preprocessor directives, instructions, registers, constants, and other NASM-specific constructs, as well as text objects for macros, structures, and comments.

runtime/queries/nasm · high confidence

Added support for the Windows Batch language, including syntax highlighting (keywords, variables, strings, comments), indentation rules, text objects, and tag definitions. This enables features like code folding, navigation, and improved editing experience for .bat and .cmd files.

runtime/queries/batch, runtime/queries/robots.txt · high confidence

Added support for the \shellcheckrc\ language, including syntax highlighting queries (highlights.scm) that colorize directives, operators, and identifiers, as well as textobject queries (textobjects.scm) that allow users to select or navigate around configuration directives. This enables proper visual feedback and editing capabilities for shellcheckrc files in the editor.

runtime/queries/shellcheckrc · high confidence

New query files are added to runtime/queries/fish/ to provide syntax highlighting, indentation, local variable scoping, and text object definitions for the Fish shell. This includes highlighting for operators, conditionals, loops, built-in commands, functions, strings, and variables, as well as support for injecting jq and Nu (Nushell) code blocks within Fish scripts.

runtime/queries/fish · high confidence

New files in runtime/queries/rshtml provide syntax highlighting rules (highlights.scm), language injection for HTML and Rust code blocks (injections.scm), and text object definitions (textobjects.scm) for the RsHtml template language, enabling proper code navigation and visual styling for this template syntax.

runtime/queries/rshtml, runtime/queries/templ · high confidence

New files are added to \runtime/queries/wesl/\ to provide syntax highlighting, local scope resolution, and text object definitions for the WESL language. This includes \highlights.scm\ for token coloring, \locals.scm\ for variable scoping, \injections.scm\ for comment injection, and \textobjects.scm\ for structural navigation, enabling full language support in the editor.

runtime/queries/amber, runtime/queries/wesl · high confidence

Users will now see syntax-highlighted code for CEL (Common Expression Language) and SpiceDB schema files. This includes highlighting for operators, keywords, identifiers, function calls, and literals, improving readability and code navigation in these languages.

runtime/queries/cel · high confidence

Users will now see syntax highlighting for DTD (Document Type Definition) files. This includes keywords like ELEMENT and ATTLIST, directives such as \#REQUIRED and \#IMPLIED, constants like SYSTEM and PUBLIC, and string literals for element and attribute names, improving the visual distinction of DTD syntax in the editor.

(repo-wide) · high confidence

Users will now see syntax highlighting for Dune project files, with the highlighter inheriting from the Scheme language configuration.

runtime/queries/dune · high confidence

Users will now see syntax-highlighted ESDL (EdgeDB schema) files in the editor. This change introduces a new highlighting configuration for the esdl language, defining keywords (such as module, type, property, link), built-in types (like str, int64, json), and other language constructs with appropriate semantic tokens. This improves the readability of schema definitions by visually distinguishing between different element types, such as identifiers, strings, comments, and delimiters.

runtime/queries/esdl · high confidence

Users can now see syntax-highlighted DTS files with support for keywords, directives, operators, delimiters, brackets, strings, constants, variables, functions, labels, properties, tags, references, and comments.

runtime/queries/devicetree · high confidence

The editor now provides syntax highlighting for KCL files. This change adds a new highlight configuration file that maps KCL's Abstract Syntax Tree nodes—such as keywords, functions, operators, and literals—to specific highlighting classes, enabling proper visual differentiation of code elements in supported editors.

runtime/queries/kcl · high confidence

The editor now provides syntax highlighting for Mermaid diagram code blocks in Markdown files. This change adds a new query file that defines highlighting rules for various diagram types including sequence, class, state, gantt, pie, and flowchart diagrams, ensuring that keywords, labels, and structural elements are visually distinguished in the editor.

runtime/queries/mermaid · high confidence

Introduces a new highlights.scm file for the Pod language, enabling syntax highlighting in editors that support treesitter. This includes styling for headings (head1-head6), various commands (over, item, encoding), verbatim text, and interior sequences (B, C, F, I, L, X) as well as escape sequences, mapping them to appropriate semantic categories like headings, keywords, markup, and strings.

runtime/queries/pod · high confidence

Users will now see syntax highlighting for PowerShell scripts. This change introduces new query files (highlights.scm, injections.scm, and rainbows.scm) that define how PowerShell keywords, operators, variables, and other language constructs are visually distinguished in the editor.

(repo-wide) · medium confidence

Syntax highlighting for Pug templates is now supported. The change adds highlight queries for Pug-specific constructs including tags, attributes, control flow keywords, mixins, includes, inheritance blocks, filters, and inline JavaScript, enabling proper visual parsing of Pug files.

runtime/queries/jinja, runtime/queries/nunjucks, runtime/queries/nearley, runtime/queries/pug · high confidence

Introduces syntax highlighting rules for RPM spec files, enabling proper visual distinction of macros, variables, keywords, and control structures within the spec file syntax.

runtime/queries/rpmspec · high confidence

Added syntax highlighting and injection support for Rego files, enabling proper keyword, function, and comment styling in the editor.

runtime/queries/rego · high confidence

Users editing SSH client configuration files (e.g., \~/.ssh/config) will now see syntax highlighting. This change introduces a new highlight definition file that maps SSH configuration keywords (such as Host, IdentityFile, and ForwardAgent) to appropriate text object types (like @keyword, @string, and @constant), improving readability and navigation within these files.

_runtime/queries/ssh\_client\config · high confidence

Users will now see syntax highlighting for Smithy query files, with keywords, types, members, and other elements visually distinguished in the editor.

runtime/queries/smithy · high confidence

Users will now see syntax highlighting for the WebAssembly Text (WAT) format. This change introduces a new \highlights.scm\ file that defines keyword, string, comment, and numeric constants for WAT, and adds missing assertion and script keywords to the existing WAT highlight rules. This enables proper visual distinction of WAT code in the editor.

runtime/queries/wat · high confidence

Users will now see syntax highlighting for Xena OpenAutomation (xtc) files. This change adds a new highlight query file (highlights.scm) that maps XTC-specific syntax elements—such as parameters, change ports, templates, various argument types, comments, and brackets—to corresponding Tree-sitter scopes (e.g., @keyword, @function.special, @variable, @attribute, @constant.numeric, @tag, @string, @comment, @label, @punctuation.bracket).

runtime/queries/xtc · medium confidence

Users editing dunst configuration files (dunstrc) will now see syntax highlighting, including attributes, comments, brackets, operators, and section headers.

runtime/queries/dunstrc · high confidence

Syntax highlighting for regular expressions is now supported, with a new highlights query file defining categories for brackets, operators, escapes, and quantifiers, alongside a rainbows file that groups matching brackets and scopes for visual consistency.

runtime/queries/regex · high confidence

A new syntax highlighting configuration for the Blueprint language has been added to the runtime. The highlights.scm file defines how various Blueprint constructs are visually represented in the editor, including object IDs, strings, comments, constants, templates, decorators, property definitions, signal bindings, menu definitions, and import statements.

(repo-wide) · medium confidence

Users can now have their Elvish shell scripts syntax-highlighted in the editor. This change introduces new highlight and injection query files for the Elvish language, enabling proper colorization of keywords, variables, functions, and other language constructs.

runtime/queries/elvish · high confidence

Users can now use syntax highlighting and indentation support for Mojo files. This change introduces new query files (highlights, indents, injections, locals, and textobjects) in the runtime/queries/mojo directory. The highlight definitions cover variables, literals, imports, functions, types, and operators, while the other files inherit from Python to provide basic structural support.

runtime/queries/chuck, runtime/queries/mojo · high confidence

Users can now see syntax-highlighted code for VHS scripts in the editor. This change introduces a new query file (highlights.scm) that defines keyword, type, and other token styles for VHS, enabling proper visual differentiation of commands like 'Output', 'Type', and configuration options such as 'FontFamily' and 'Theme'.

runtime/queries/vhs · high confidence

New query files (folds, highlights, indents, injections, textobjects) are added for the LaTeX language, enabling syntax highlighting, code folding, indentation, and text object selection for LaTeX documents.

runtime/queries/latex · high confidence

New query files (folds.scm, highlights.scm, injections.scm, rainbows.scm) are added to runtime/queries/tsq, enabling syntax highlighting, code folding, and rainbow bracket support for Tree-sitter query (.tsq) files. This improves the editing experience for users writing or maintaining Tree-sitter queries.

runtime/queries/tsq · high confidence

New query files (fold, highlights, indents, injections, rainbows, tags, textobjects) are added for the Perl language, enabling syntax highlighting, code folding, indentation, rainbow brackets, tag generation, and text object selection for Perl source files.

runtime/queries/perl · high confidence

New query files have been added to the MATLAB language support, enabling syntax highlighting, proper indentation, code folding, and text object selection for MATLAB and Octave files. This includes definitions for keywords, operators, variables, and control structures, ensuring that MATLAB code is correctly parsed and displayed in the editor.

runtime/queries/matlab · high confidence

New query files are introduced for the YAML language, providing syntax highlighting for scalars, comments, and structure, as well as indentation rules for block sequences and mappings. Additionally, Bash code injection is enabled for 'run', 'command', and 'commands' keys, allowing syntax highlighting within GitHub Actions and Buildkite CI configurations.

runtime/queries/yaml · high confidence

Adds new query files for Vue single-file components, enabling syntax highlighting for Vue-specific elements like directives and interpolations, proper indentation for template and script blocks, and language injection for embedded JavaScript and CSS. This allows editors to correctly parse and format Vue SFCs, treating template content as HTML-like elements while injecting appropriate languages for script and style blocks.

runtime/queries/vue · high confidence

Users can now use the Meson build language with proper syntax highlighting, indentation, and comment injection support. The new query files define how Meson code is highlighted (e.g., keywords, operators, strings, comments), how it is indented (e.g., inside if/foreach/command blocks), and how comments are injected for syntax highlighting. This enables basic language support for Meson files in the editor.

runtime/queries/meson · high confidence

Users will now see proper syntax highlighting, indentation, and rainbow bracket matching for the Spade language. This includes keyword categorization (e.g., \pipeline\, \let\, \entity\), type and variable highlighting, operator styling, and comment recognition. Indentation rules are defined for constructs like \struct\, \enum\, \impl\, \match\, and various literal types. Rainbow brackets are enabled for scopes such as \impl\, \trait\, \enum\_body\, and generic parameters.

runtime/queries/janet, runtime/queries/spade · high confidence

New syntax support for Makefiles has been added, introducing comprehensive highlighting for Make-specific constructs (such as variables, functions, and targets), improved indentation rules for directives and rules, and shell code injection for shell commands within Makefiles.

runtime/queries/make · high confidence

New language support has been added for BASIC and FreeBASIC, including syntax highlighting for keywords, operators, and comments; indentation rules for FOR/NEXT blocks; and variable tagging for let and for statements. This enables proper code navigation, editing, and visual feedback for these languages.

runtime/queries/basic · high confidence

New query files (highlights, indents, tags, textobjects) are added for the FreeBASIC language, enabling syntax highlighting, proper indentation for control structures like IF/WHILE/FOR, and function/sub declarations for navigation and tagging.

runtime/queries/freebasic · high confidence

Protobuf (.proto) files now receive full language support, including syntax highlighting for keywords, types, and literals; automatic indentation for message, enum, service, and RPC blocks; and text object queries for navigating classes, functions, and comments. This enables proper visual styling, correct auto-indentation, and improved code navigation in Protobuf files.

runtime/queries/protobuf, runtime/queries/sgf · high confidence

New query files are added for Scala, providing syntax highlighting (highlights.scm), indentation rules (indents.scm), and text object definitions (textobjects.scm). The highlighting rules define scopes for variables, types, functions, and keywords. The indentation queries specify how blocks, definitions, and expressions should be indented. The textobject queries allow selection of functions, classes, and parameters. Additionally, injection queries (injections.scm) are added to support SQL interpolation for libraries like Doobie, Quill, and Slick.

(repo-wide) · high confidence

New query files (highlights, indents, injections, and textobjects) are added for the V programming language. This provides syntax highlighting for V's keywords, types, functions, and literals; indentation rules for control flow and declarations; injection of SQL in V's sql expressions; and text objects for selecting functions, classes, and comments. Users will see V code properly highlighted and indented, with improved navigation and selection capabilities in editors that support these queries.

runtime/queries/v · high confidence

Users can now edit Luau code with proper syntax highlighting, indentation, and text object support. This change introduces new query files for the \luau\ language, including \highlights.scm\ for coloring keywords, operators, and types; \indents.scm\ for automatic indentation of control structures and function bodies; \injections.scm\ for highlighting Lua patterns in string arguments; \locals.scm\ for local variable scoping; and \textobjects.scm\ for selecting function and parameter ranges.

runtime/queries/c, runtime/queries/luau · high confidence

Users can now edit Slint files with proper syntax highlighting, automatic indentation, and text-object navigation. This change introduces new query files (highlights.scm, indents.scm, injections.scm, locals.scm, textobjects.scm) that define how Slint's grammar is parsed and displayed, enabling features like keyword coloring, block indentation, and selection of function/class scopes.

runtime/queries/slint · high confidence

New query files have been added for the Zig language, enabling syntax highlighting, indentation, text objects, and tag generation. This includes defining how identifiers, types, constants, keywords, and control flow are highlighted, as well as specifying indentation rules for blocks and control structures. Additionally, text objects for functions, tests, classes, parameters, and comments are now supported, along with basic injection for comments.

(repo-wide) · high confidence

New query files for JSX (highlights, indents, and textobjects) are introduced to provide first-class support for the language. Syntax highlighting now distinguishes JSX element tags, self-closing tags, and attributes (including those starting with an uppercase letter as constructors). Indentation rules ensure that closing tags and self-closing delimiters align correctly with their opening tags. Textobject queries allow users to select entire JSX elements and their contents using standard textobject selections.

(repo-wide) · high confidence

New query files are added to the runtime/queries/tablegen directory, providing syntax highlighting rules for TableGen (LLVM's TableGen language), including keywords, operators, and comments. The changes also introduce indentation rules for statement blocks and closing braces, as well as textobject definitions for selecting classes, multiclasss, parameters, and comments. This enables proper visual formatting and editing capabilities for TableGen source files.

(repo-wide) · high confidence

Users can now use Sway source files with full IDE support, including syntax highlighting, automatic indentation, and textobject navigation. This change introduces new query files for Sway in the runtime/queries/sway directory, defining how the editor should interpret and style Sway code.

runtime/queries/sway · high confidence

New query files are added for the Hurl language, enabling syntax highlighting, indentation, code injection, and textobject navigation for .hurl files. The highlights define tokens for query parameters, headers, cookies, asserts, and various built-in functions and operators, while the indents file configures bracket and XML tag indentation. Injections allow JSON, XML, and multiline strings within Hurl files to be highlighted correctly, and textobjects provide comment and function navigation.

runtime/queries/docker-compose, runtime/queries/hurl · high confidence

Users can now use QML with full syntax highlighting, proper indentation, text object selection, and JavaScript code injection. This change introduces new query files (highlights.scm, indents.scm, injections.scm, textobjects.scm) that define how QML code is parsed and displayed, including support for UI components, properties, signals, and inline JavaScript blocks.

runtime/queries/qml · high confidence

The editor now provides structured syntax highlighting for Git commit messages, including headers, prefixes, trailers, and diff sections. It also enables language injection for embedded diffs and rebase commands, and defines textobject ranges for comments, allowing users to select or operate on commit message content more effectively.

runtime/queries/git-commit · high confidence

Added support for Emacs Lisp (elisp) in the syntax highlighting, local variable scoping, and tag generation systems. New query files define how special forms, function/macro definitions, strings, comments, and constants are highlighted, how scopes and parameters are identified for navigation, and how function and macro definitions are tagged for code navigation.

runtime/queries/elisp · high confidence

Users editing mail files will now see improved syntax highlighting, including headers, subjects, email addresses, and quoted reply sections. Rainbow brackets and scopes are enabled for quoted blocks, and text objects allow selection of email addresses, headers, quoted blocks, and body content.

runtime/queries/mail · high confidence

Users editing git-config files will now see syntax highlighting for sections, variables, and special strings, with regex syntax highlighting for xfuncname and wordRegex attributes. Comments are injected for proper syntax highlighting, and text objects are provided for comments and entries.

runtime/queries/git-config · high confidence

Users can now edit Prolog files with syntax highlighting, indentation, and folding support. This change adds the necessary tree-sitter grammar and query files (highlights, indents, folds, and injections) to the runtime/queries/prolog directory, enabling proper language integration for Prolog in the editor.

runtime/queries/penrose, runtime/queries/prolog · high confidence

New query files (folds, highlights, indents, injections, locals, rainbows, tags, textobjects) have been added to the Svelte runtime directory. These files define how the editor handles Svelte-specific syntax, including folding for control blocks (if, each, await), syntax highlighting for directives and expressions, indentation rules, and text-object selections for snippets and elements. This enables better code folding, syntax highlighting, and editing capabilities for Svelte components.

runtime/queries/svelte · high confidence

Added new runtime query files (folds, highlights, indents, injections) for the \tfvars\ file type, each inheriting from \hcl\ to enable syntax highlighting, folding, and indentation support for Terraform variable files.

runtime/queries/tfvars · high confidence

IEx (the Interactive Elixir shell) now receives syntax highlighting and code injection support. The new \highlights.scm\ file maps the \prompt\ node to the \@comment\ highlight group, while \injections.scm\ configures the editor to treat evaluation blocks and results as Elixir code, enabling proper syntax highlighting and language features within the IEx buffer.

runtime/queries/iex · high confidence

Added missing syntax highlighting, local variable tracking, and tag definitions for TypeScript. This enables proper colorization of TypeScript-specific keywords (such as 'abstract', 'namespace', 'implements'), parameters, and types, as well as improved code navigation features like 'go to definition' and 'find references' for TypeScript files.

_runtime/queries/\typescript · high confidence

Users will now see proper syntax highlighting and code injection for WebC files, as new highlight and injection query files have been added to the runtime/queries/webc directory, both inheriting from HTML.

runtime/queries/webc · high confidence

Users can now benefit from syntax highlighting and language injection for Djot files. New highlight rules define visual styles for headings, lists, blockquotes, tables, and inline formatting like bold and italic. Additionally, code blocks, raw blocks, and math content are injected with appropriate syntax highlighting (e.g., LaTeX for math), improving code comprehension and editing experience for Djot documents.

runtime/queries/djot · high confidence

New query files (folds, highlights, indents, injections, locals) have been added to the Kconfig language support, enabling syntax highlighting, code folding, indentation, and local variable scoping for Kconfig configuration files.

runtime/queries/kconfig · high confidence

Users editing GNU gettext PO (Portable Object) files will now have syntax highlighting for message context, IDs, strings, and comments, as well as text object queries for selecting message IDs and comments.

runtime/queries/po · high confidence

Users can now use syntax highlighting and text object selection for Java .properties files. This includes proper highlighting for comments, keys, values (including booleans, floats, integers, and escape sequences), and substitutions, as well as enabling text object selection for comments and properties.

runtime/queries/properties · high confidence

New files in runtime/queries/picat provide syntax highlighting, indentation rules, local variable scoping, rainbow bracket matching, tag definitions, and text objects for Picat. This enables editors to correctly highlight Picat code, auto-indent based on language structure, identify local variables and function definitions, and support text-object navigation for functions, parameters, and comments.

runtime/queries/gleam, runtime/queries/picat · high confidence

Syntax highlighting rules for the DBML query language have been added to the runtime/queries/dbml directory. This includes highlighting for comments, keywords, identifiers, database types (such as Project, Table, and TableGroup), strings, numbers, and punctuation, enabling proper visual distinction of DBML syntax in the editor.

runtime/queries/dbml · high confidence

Added new highlight and injection rules for Go's go.mod and go.work files. This enables syntax highlighting for keywords such as 'require', 'replace', 'go', 'toolchain', 'tool', 'exclude', 'retract', 'module', and 'use', as well as string literals for versions and comments.

runtime/queries/gomod · high confidence

Syntax highlighting has been added for pip requirements files, enabling proper visual distinction of package names, version constraints, markers, and other elements within those files.

runtime/queries/diff, runtime/queries/pip-requirements · high confidence

Users will now see syntax highlighting for the GN (Generate Ninja) build language. This change adds new highlight queries for GN files, defining how identifiers, functions, keywords, operators, strings, and comments are visually distinguished in the editor.

runtime/queries/gn · high confidence

Users will now see syntax highlighting for the hosts file, with comments, IP addresses, and hostnames being highlighted appropriately.

runtime/queries/hosts · high confidence

Added a new syntax highlighting configuration for the todo.txt file format, enabling visual distinction of task elements such as priorities, dates, key-value pairs, projects, and contexts within the editor.

runtime/queries/todotxt · high confidence

The editor now supports the Nickel language with new query files that define syntax highlighting, indentation, and code injection rules. Specifically, the \highlights.scm\ file provides tokenization for types, keywords (including \rec\), literals, and operators, while \indents.scm\ configures indentation for expressions and blocks. Additionally, \injections.scm\ enables Markdown injection for documentation strings. These changes enable proper visual formatting and structure awareness for Nickel source files.

runtime/queries/nickel · high confidence

Users will now see improved syntax highlighting, code folding, text object selection, and tag/locals support for Haskell and Haskell Persistent files. This includes specific highlighting for keywords, operators, and types, as well as enabling features like code folding for declarations and selecting function or class regions for editing.

runtime/queries/haskell · high confidence

The xtask now includes a docgen module that automatically generates Markdown files for the project's typable and static commands, as well as a language support matrix. This automation ensures that the documentation for available commands, their default keybindings, and supported language features is kept up-to-date with the codebase.

xtask · high confidence

Added syntax highlighting rules for Debian control files, enabling comments and field names to be visually distinguished in the editor.

runtime/queries/debian · high confidence

Added support for LSP file operations (create, rename, delete) and file change notifications. The \file\_operations.rs\ module parses server capabilities to filter file system events, while \file\_event.rs\ manages subscriptions to watch for file changes and forwards them to the appropriate LSP clients. The \client.rs\ module was updated to handle workspace folder registration and management, allowing the editor to track multiple workspace roots for a single language server.

helix-lsp · high confidence

Added comprehensive C\# language support, including syntax highlighting for types, methods, variables, and keywords; text objects for selecting classes, functions, and parameters; local variable and scope tracking; indentation rules; rainbow bracketing; and tag definitions for class, interface, method, and namespace navigation.

runtime/queries/c-sharp · high confidence

Added new query files for Erlang that enable syntax highlighting (including records, macros, and attributes), automatic indentation, text objects for functions and comments, and tag/locals support for code navigation and refactoring.

runtime/queries/erlang · high confidence

The editor now renders diagnostics inline within the code view, displaying each message line separately to improve readability. This change introduces new theme keys (e.g., \hint.diagnostic.inline\) to style these inline diagnostics, allowing users to customize the appearance of hints, info, warnings, and errors directly in the editor. The implementation handles edge cases such as screen boundaries and stacked diagnostics, ensuring that diagnostic text is truncated appropriately and rendered with the correct severity-based styling.

_helix-term/src/ui/text\decorations · high confidence

The terminal UI layer is now implemented in a new \helix-tui\ crate, which is an inlined fork of the ratatui library. This change introduces a new module structure for terminal rendering, including buffer management, layout calculations, and text styling primitives, allowing Helix to maintain direct control over the terminal interface while adopting the established ratatui API.

helix-tui/src · high confidence

Adds comprehensive syntax highlighting, indentation rules, and text object queries for the Rust language. This includes defining scopes for operators, paths, types, comments, and punctuation, as well as indentation logic for blocks, closures, and expressions. It also adds text objects for functions, classes, parameters, and comments, along with rainbow bracketing for Rust syntax. Additionally, it introduces a new \markdown-rustdoc\ query file to handle Rust documentation comments as Markdown, and a \rust-format-args\ query file to highlight format string arguments.

runtime/queries/rust · medium confidence

The Helix editor now includes a dedicated \helix-dap\ crate that implements the Debug Adapter Protocol (DAP) client. This adds support for connecting to debug adapters via stdio or TCP, managing multiple debugger clients, and handling DAP events and requests. This provides the foundational infrastructure for debugging support in the editor.

helix-dap · high confidence

A new \helix-dap-types\ crate has been added to the project, extracting DAP-related data structures and serialization logic into a dedicated module. This includes definitions for thread IDs, breakpoint states, source maps, and debugger capabilities, providing a centralized and reusable type system for the Debug Adapter Protocol.

helix-dap-types · high confidence

Added the helix-parsec crate, a new parser-combinator library providing a \Parser\ trait and combinators such as \token\, \take\_until\, \take\_while\, and \seq\ for functional composition of parsers. This new library is used to optimize LSP snippet parsing, replacing previous ad-hoc parsing logic with a structured combinator approach.

helix-parsec · high confidence

A new \helix-stdx\ crate has been created to house shared utility functions used across the codebase. This includes environment variable expansion and working directory management in \env.rs\, file access and metadata handling in \faccess.rs\, path normalization and tilde expansion in \path.rs\, a generic \Range\ type in \range.rs\, and grapheme cluster iteration for text editing in \rope.rs\. Additionally, a lightweight RFC3986-compliant URI wrapper is provided in \uri.rs\ to replace the previous \url\ crate dependency for LSP-related file URIs.

helix-stdx/src · high confidence

The helix-vcs module is introduced to provide a unified interface for version control system operations. It includes a DiffHandle for managing diff states, a Git provider implementation for retrieving file diffs and head names, and a status module defining file change states (Untracked, Modified, Conflict, Deleted, Renamed). The DiffProviderRegistry allows for future expansion to other VCS providers, though currently only Git is supported. This change enables the editor to display and interact with version control information, such as showing changed files in the file picker and rendering diff signs in the gutter.

helix-vcs/src · high confidence

Added a new \helix-event\ crate that provides a synchronous hook system for editor events, allowing components to register callbacks that run when specific events are dispatched. The system supports both synchronous hooks for immediate state modification and asynchronous hooks with debouncing for background tasks. It also includes utilities for managing task cancellation, requesting UI redraws, and reporting status messages.

helix-event · high confidence

The completion handler now supports path and word completions in addition to LSP. Path completion scans the filesystem to suggest files and directories, while word completion suggests words from the current buffer. Both are implemented as distinct completion providers that integrate with the existing completion UI, allowing users to navigate and insert file paths or buffer words directly.

helix-term/src/handlers/completion · high confidence

The helix-view crate now includes a new \Action\ struct that serves as a provider-agnostic representation of editor actions, such as LSP code actions and internal features like spell checking. This allows all actions to appear in the same menu. Additionally, the crate introduces \InlineDiagnosticsConfig\ and related modules to support rendering inline diagnostics in the editor, with configurable filtering by severity and display options for cursor and other lines.

helix-view/src · high confidence

The helix-core crate now includes several new modules that provide foundational editing capabilities. The \auto\_pairs\ module handles automatic insertion and deletion of character pairs like brackets and quotes. A \case\_conversion\ module adds functions to transform text to camelCase, PascalCase, and upper/lower case. The \chars\ module introduces a \CharCategory\ enum to categorize characters as whitespace, end-of-line, word, or punctuation. Command-line parsing is handled by the new \command\_line\ module, which defines \Flag\ and \Signature\ structs for robust argument parsing. The \comment\ module implements logic for toggling line and block comments. Completion items are defined in \completion.rs\, and configuration loading is managed by \config.rs\, which handles both default and user-provided language configurations.

helix-core/src · high confidence

The default keymap is now defined in a new \default.rs\ file, providing a comprehensive set of keybindings for normal, insert, and command modes. This includes navigation, selection, editing, and LSP-related commands. The \keymap!\ macro in \macros.rs\ has been introduced to simplify the definition of these keybindings, supporting multi-key sequences and nested menus.

helix-term/src/keymap · high confidence

The \helix-term/src/handlers\ directory has been refactored into a set of new, dedicated handler modules to manage distinct editor features. These include \auto\_save.rs\ for debounced auto-saving, \code\_action\_hint.rs\ for displaying code action suggestions, \completion.rs\ for managing auto-completion and path completion, \diagnostics.rs\ for handling pull-based and push-based diagnostic updates, \document\_colors.rs\ for rendering color swatches, \document\_highlight.rs\ for automatic symbol highlighting, \document\_links.rs\ for managing document links, \prompt.rs\ to dismiss prompts on focus loss, \signature\_help.rs\ for function signature popups, \snippet.rs\ for managing active snippets, and \workspace\_trust.rs\ for prompting users to trust workspaces. Each module registers event hooks to coordinate with the rest of the editor.

helix-term/src/handlers · high confidence

Added new query files for Python to define syntax highlighting, indentation rules, text objects, and other language-specific behaviors. The \highlights.scm\ file establishes tokenization for operators, keywords, variables, and types, while \indents.scm\ configures indentation logic for control structures and blocks. Additionally, \injections.scm\ enables regex highlighting for the \re\ module, and \textobjects.scm\ defines navigation and selection ranges for functions, classes, and parameters.

runtime/queries/python · high confidence

Added Racket-specific query files for syntax highlighting, indentation, injections, and rainbow brackets, all inheriting from the Scheme configuration. This enables proper syntax highlighting, indentation behavior, and bracket matching for Racket files.

runtime/queries/racket · high confidence

The command-line parsing has been rewritten to support flags and expansions, which changes how quoting and spaces are handled; this may break existing keymaps that use typable commands like :sh or :set-option. A new picker for exploring directories has been added, and the highlighter has been switched to the tree-house crate, which improves local variable highlighting and Markdown injection in Rust doc comments.

(repo-wide) · high confidence

Added syntax highlighting rules for the xit query language, mapping elements like headlines, checkboxes, tasks, and priorities to specific highlight groups (e.g., @markup.heading, @keyword.control, @error).

runtime/queries/xit · high confidence

The \lsp-types\ crate is now vendored into the codebase as \helix-lsp-types\. This fork replaces the external \url::Url\ dependency with a simple string wrapper for URLs, as Helix only supports the \file://\ scheme and requires RFC3986 compliance. The module includes types for call hierarchy, code actions, code lenses, color presentation, completion, document diagnostics, document highlights, document links, document symbols, error codes, file operations, and folding ranges, enabling the editor to communicate with language servers using the latest LSP protocol features.

helix-lsp-types · high confidence

The build script for helix-term was updated to automatically locate the Windows SDK and use the RC compiler to embed the icon file (../contrib/helix-256p.ico) into the final Windows executable. This ensures that Windows users see the correct application icon in the file explorer and taskbar. Additionally, the build script now handles fetching and compiling tree-sitter grammars during the build process, and the helix-term README was removed.

helix-term · high confidence

The loader now enforces workspace trust before loading workspace-local \.helix/languages.toml\ and \.helix/config.toml\. If a workspace is not trusted, only the global configuration is loaded, and a notice is printed to the console. This prevents untrusted workspaces from executing arbitrary code via local language server configurations.

helix-loader/src · high confidence

The \helix-term/src/ui\ directory is reorganized by extracting the \completion\, \document\, \editor\, and \info\ components into their own dedicated source files (\completion.rs\, \document.rs\, \editor.rs\, \info.rs\). This change improves code modularity and maintainability by separating distinct UI concerns into individual modules rather than keeping them all in a single large file.

helix-term/src/ui · high confidence

The \helix-term/src/commands\ directory has been restructured by extracting specific command implementations into dedicated files: \dap.rs\ for debugger (DAP) commands, \lsp.rs\ for language server protocol commands, \syntax.rs\ for syntax/tree-sitter commands, and \typed.rs\ for all typable commands. This refactoring improves code organization and maintainability without changing user-facing behavior.

helix-term/src/commands · high confidence

The configuration structs for language syntax (such as LanguageConfiguration and FileType) have been extracted from the main syntax module into a separate config.rs file. This refactoring improves code organization and maintainability without changing user-facing behavior.

helix-core/src/syntax · high confidence

Added syntax highlighting rules for HEEx templates, including delimiters, operators, tags, attributes, and components. Elixir code within HEEx directives and expressions is now injected for proper syntax highlighting. Additionally, comment textobjects are defined to allow selection of comment regions.

runtime/queries/heex · high confidence

New syntax highlighting, indentation, injection, local, rainbow, and textobject query files are added for TypeScript. These files inherit from the shared 'ecma' and '\_typescript' base queries, ensuring that TypeScript code is now properly highlighted, indented, and supports text-object navigation and rainbow brackets, aligning its behavior with other ECMAScript-based languages.

runtime/queries/doxyfile, runtime/queries/typescript · high confidence

The JSX language support is now separated from JavaScript, with new query files (highlights, indents, injections, locals, rainbows, tags, and textobjects) created in the jsx directory. Each file inherits from ecma, \_javascript, and \_jsx, ensuring that JSX-specific syntax receives appropriate highlighting, indentation, and text-object support while reusing the shared ecma logic.

runtime/queries/jsx · medium confidence

Added support for Helm chart templates by introducing syntax highlighting and code injection. The new \runtime/queries/helm/highlights.scm\ file inherits Go template highlighting rules, while \runtime/queries/helm/injections.scm\ configures the editor to treat text nodes within Helm templates as YAML for proper syntax highlighting and injection.

runtime/queries/helm · high confidence

JSDoc comments in JavaScript and TypeScript files now receive syntax highlighting and syntax-aware injection. Tag names are highlighted as keywords, types as types, and numbers as constants. Additionally, fenced code blocks within JSDoc comments (such as @example) are injected with the specified language for proper highlighting.

runtime/queries/jsdoc · high confidence

Users will now see syntax highlighting for Org mode documents, including headings, bold, italic, and raw text. Additionally, code blocks within Org files will be highlighted according to their respective language syntax.

runtime/queries/org · high confidence

Users editing mise configuration files (TOML) will now see improved syntax highlighting, indentation, and text object support. Additionally, the 'tasks' section of the configuration will have Bash syntax highlighting and code injection applied to the 'run' fields, enabling better editing experience for task definitions.

runtime/queries/miseconfig · high confidence

New syntax highlighting rules and comment injection queries have been added for the Forth programming language. This includes definitions for keywords, control flow, I/O operations, operators, core builtins, various number and string literals, and user-defined words, along with support for line and block comments.

runtime/queries/forth · high confidence

Users editing FIDL (Fuchsia Interface Definition Language) files will now have syntax highlighting, keyword recognition, and code folding support. This includes highlighting for FIDL keywords (such as protocol, service, struct, enum), operators, attributes, and literals, as well as enabling folding for layout, protocol, resource, and service declarations.

runtime/queries/fidl · high confidence

Users editing MediaWiki Wikitext files will now see improved syntax highlighting and code folding. The update adds support for highlighting headings (h1-h6), wikilinks, external links, templates, comments, and HTML tags, as well as structural folding for sections.

runtime/queries/wikitext · high confidence

Added new syntax highlighting and injection query files for EEx (Embedded Elixir) templates. The changes introduce specific highlighting rules for EEx directives (such as \\<%\ and \%\>\) and configure language injection to treat EEx expressions as Elixir code, enabling proper syntax highlighting and code folding within these templates.

runtime/queries/eex · medium confidence

Users will now see improved syntax highlighting and code injection for jjconfig files, including support for inline scripts in aliases, as well as new highlighting rules for jjrevset and jjtemplate languages.

runtime/queries/jjconfig · high confidence

Users can now use text objects to select comments and variable assignments in .env files, and syntax highlighting for these files is inherited from Bash.

runtime/queries/env · high confidence

New query files (highlights, indents, injections, textobjects) are added for Pest, enabling syntax highlighting, indentation, comment injection, and textobject navigation for that language.

runtime/queries/pest · high confidence

Users will now see syntax highlighting for the 'editmsg' command in git notes, with comments in that context being highlighted as @comment.

runtime/queries/git-notes · high confidence

The git-attributes language now includes syntax highlighting for attribute names, values, and operators. Specifically, the diff configuration attribute is highlighted to show supported built-in language types (such as 'ada', 'bash', 'cpp', etc.), improving the visual distinction of these values in the editor.

runtime/queries/git-attributes, runtime/queries/klog · high confidence

Users will now see syntax highlighting for the Alloy configuration language. This change introduces a new highlight query file that defines how various elements are visually represented, including literals (booleans, comments, strings, numbers, and null), punctuation (brackets and delimiters), operators, function definitions, attributes, and blocks.

runtime/queries/alloy · high confidence

License files have been added to the runtime/themes/licenses directory for a variety of themes, including Akari, Ashen, Aura, Carbonfox, Dark Synthwave, Doom One, Everforest, Faded Prism, JetBrains Cyan Light, Kinda Nvim, Lapis Aquamarine, Modus Vivendi (and its variants), Noctis, Poimandres, and Quiet Light. This ensures that the licensing terms for these themes are properly documented and accessible.

runtime/themes/licenses · high confidence

Syntax highlighting for LPF (Low Power Format) files has been added. This includes keywords such as SYSCONFIG, BLOCK, LOCATE, COMP, FREQUENCY, PORT, and IOBUF, as well as support for SITE, operators, numbers, strings, and line comments.

runtime/queries/lpf · high confidence

Users will now see improved language support for Ada, specifically through the addition of a new syntax highlighting configuration file (highlights.scm) for the GPR language. This change introduces keyword, operator, comment, string, numeric, type, variable, function, attribute, and package highlighting rules tailored to the GPR project file format, enabling better visual distinction of GPR-specific syntax in the editor.

runtime/queries/gpr · medium confidence

The new \helix-loader/build.rs\ script captures the current git commit hash and constructs a calendar version string (e.g., \YY.0M\ or \YY.MM.PATCH\) from Cargo package metadata. This information is exposed to the Rust compiler via \cargo:rustc-env\ as \BUILD\_TARGET\, \VERSION\_AND\_GIT\_HASH\, and related environment variables, enabling the application to report its precise build version and revision at runtime.

helix-loader · high confidence

The documentation site now uses a custom 'colibri' theme with a dark color palette, updated typography, and improved spacing. A JavaScript module adds a version banner to distinguish between stable, nightly (master), and archived release documentation, and provides a landing-page tile selector. Syntax highlighting for Tree-sitter query files (scm/tsq) is also included.

book · high confidence

The editor now applies specific syntax highlighting to various types of comments, improving readability and organization. This change introduces distinct visual styles for different comment categories: hints (e.g., HINT, TIP), information (e.g., INFO, TODO, REVIEW), warnings (e.g., HACK, WARN), and errors (e.g., BUG, FIXME, SECURITY). Additionally, issue numbers (e.g., \#123) and user mentions (e.g., @user) are now highlighted as constants or tags, making them easier to spot in the code.

runtime/queries/comment · high confidence

The LSP hover popup now supports cycling through results from multiple language servers, displaying a header for each result. The signature help popup has been updated to match the hover component's style, adding scrolling support and fixing an overflow issue that previously caused content to be cut off.

helix-term/src/ui/lsp · high confidence

Syntax highlighting for Rust's \format!\ and related macros is now handled by a dedicated \rust-format-args\ language definition. This new configuration inherits from the standard Rust grammar and injects itself into string literals within these macros, ensuring that format specifiers and arguments are highlighted correctly. This change fixes the previous issue where these macros were not properly highlighted.

runtime/queries/rust-format-args-macro · medium confidence

The runtime/grammars directory has been initialized with a .gitkeep file, establishing the location where grammar libraries will be dynamically loaded at runtime.

runtime/grammars · medium confidence

The query files for JavaScript, JSX, and TypeScript are now split into private (underscore-prefixed) and public versions to support a new inheritance model. Common queries for Ecma-based languages are now defined in the shared \ecma/\ directory, while language-specific overrides are placed in \\_javascript/\, \\_jsx/\, and \\_typescript/\. This allows other languages to inherit from the base \ecma\ queries, ensuring consistent highlighting, indentation, and text object behavior across JavaScript, TypeScript, and JSX while allowing for specific deviations.

runtime/queries/ecma · high confidence

The JavaScript query files (highlights, indents, injections, locals, rainbows, tags, and textobjects) now explicitly inherit from the shared 'ecma' base. This change allows JavaScript to leverage common query definitions for the ECMAScript language family, while retaining specific overrides where necessary, such as the 'using' keyword in highlights.scm.

runtime/queries/javascript · medium confidence

The handlers in helix-view have been reorganized into dedicated modules: completion.rs (tracking completion state and events), dap.rs (debugger protocol handling), diagnostics.rs (debounced cursor-line diagnostics), lsp.rs (LSP event handling and edit application), and word\_index.rs (lexical completion index). These modules introduce new event types and handler structures that manage their respective subsystems, improving code organization and enabling reuse across the editor.

helix-view/src/handlers · high confidence

The picker's query parsing and dynamic query handling have been refactored. A new \PickerQuery\ struct in \query.rs\ introduces a special \%fieldname\ syntax to select specific columns for filtering, and the \DynamicQueryHandler\ in \handlers.rs\ now uses an \AsyncHook\ to manage query debouncing, with a specific fix to skip debounce for paste events to ensure immediate updates.

helix-term/src/ui/picker · high confidence

The editor now propagates the idle timeout event to all components, ensuring that the idle timeout configuration is respected across the application. This change allows the editor to remain responsive to user input while idle, preventing the application from becoming unresponsive during long idle periods.

helix-term/src · medium confidence

The diff worker in helix-vcs now uses the imara\_diff library for computing diffs, replacing the previous implementation. A new line cache (InternedRopeLines) is introduced to optimize diffing performance by caching line data and reusing allocations. This change improves the responsiveness of the diff gutter and reduces the computational load on the editor by offloading the diffing process to a background worker that debounces events and handles timeouts gracefully.

helix-vcs/src/diff · medium confidence

The terminal backend in helix-tui has been refactored to improve how terminal capabilities are detected and managed. The code now explicitly detects support for extended underlines, synchronized output, true color, and dynamic background colors by querying the terminal. It also detects the terminal's current theme mode and restores the original background color on exit. Additionally, the backend now handles the keyboard enhancement protocol and manages cursor shape restoration more reliably.

helix-tui/src/backend · medium confidence

The documentation site's HTML template (index.hbs) has been updated to the latest mdBook structure, which includes improved handling of the sidebar, theme switching, and keyboard shortcuts. Additionally, an SVG favicon (favicon.svg) was added to the theme directory, ensuring the browser tab displays the correct icon for the book.

book/theme · high confidence

The helix-tui widget library has been refactored to improve text handling and rendering. The \Block\ widget now supports different border types (plain, rounded, double, thick) and allows styling of borders and titles. The \Paragraph\ widget now supports text wrapping with configurable trimming and alignment. The \Table\ widget's \Cell\ styling has been adjusted so that cell styles are applied to their text content rather than overwriting it. Additionally, the \List\ widget has been updated to handle selection states and scrolling more robustly.

helix-tui/src/widgets · high confidence

Syntax highlighting for GitHub Action files has been corrected. The update ensures that JavaScript code within GitHub Action workflows is properly highlighted, improving readability and code navigation for users editing these files.

runtime/queries/github-action · medium confidence

Added Windows-specific path normalization tests; Added automated indentation tests for Rust source files; Added indent and highlight test fixtures for numerous languages; Added initial test coverage for helix-tui core components; Added integration test harness for the terminal component; Added multilingual benchmark text files for word extraction; Added tests for Git diff base resolution; Expanded integration test coverage for editor commands and splits; Expanded test coverage for editor commands; Updated encoding test data for multiple character sets.

The project updated its Rust dependencies across 16 manifests, including bumping serde to 1.0.147, anyhow to 1.0.76, indexmap, grep-searcher to 0.1.12, etcetera to 0.7.1, thiserror to 1.0.44, serde\_json to 1.0.97, gix to 0.76.0, which to 8.0.0, unicode-general-category to 0.5.1, ropey to 1.2.0, rand to 0.10.1, libc, smartstring to 1.0.0, and others. These updates ensure the project uses the latest stable versions of its core libraries, improving compatibility and performance.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 38.

• Code Health 72
• Maturity 57
• Readiness 25
• Security 42

• 300 commits — 238 feature/other, 62 fixes

• (root) — 89 commits
• runtime/queries — 82 commits
• helix-term/src — 40 commits
• book/src — 15 commits
• runtime/themes — 12 commits
• helix-core/src — 11 commits
• .github/workflows — 10 commits
• helix-view/src — 9 commits
• helix-dap/src — 4 commits
• helix-lsp/src — 4 commits
• book/book.toml — 3 commits
• book/custom.css — 3 commits
• helix-loader/src — 3 commits
• helix-term/tests — 3 commits
• helix-tui/src — 3 commits
• helix-stdx/src — 2 commits
• tests/indent — 2 commits
• book/theme — 1 commit
• contrib/completion — 1 commit
• helix-view/benches — 1 commit

• fix: Add or fix locals for a wide range of languages
• fix: Fix Svelte <script> and <style> injections (#15846)
• fix: Fix cargo doc lints
• fix: Fix indents queries for switch statements
• fix: Fix integration tests on CI (#15851)
• fix: Fix justfile formatter
• fix: Fix lints
• fix: Fix robots-txt grammar name
• fix: Fix tags for multiple languages
• fix: Fix tags queries to use canonical scope names
• fix: Fix various queries that were using wrong scopes
• fix: Fix ⚠ indicator not showing if LSPs would start (#15909)
• fix: Fix: prevent crash on tabbing too far on snippets (#13634)
• fix: Revert "Add language support for Doxygen"
• fix: Spade tree-sitter: Fix match statement indent (#15855)
• fix: Update a bunch of grammars and fix up highlights
• fix: book: fix scheme aliases
• fix: ecma/injections: fix regressions (#15655)
• fix: fix precedence issues with member vars in scala/swift
• fix: fix(build): protect use of Termcode when term features is not set (#15703)
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

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.