Helix

Release 25.07 Highlights

2025-07-15T00:01:00+00:00

A long-awaited 25.07 release is finally here. This release saw the replacement of a major, core component of Helix and the addition of plenty of flashy features besides. This release saw changes from 195 contributors. A hearty thank you to everyone who made this release possible.

New to Helix? Helix is a modal text editor with built-in support for multiple selections, Language Server Protocol (LSP), tree-sitter, and experimental support for Debug Adapter Protocol (DAP).

Buckle up; these release notes will get a bit technical as we talk about our new bindings to Tree-sitter, tree-house</code>. Before we get into the weeds, let's see check out flashier features.

File explorer</h2> </asciinema-player> 25.07 adds a file explorer under <space>e</code>. The file explorer is a picker, a telescope</a>-like UI component central to Helix. Like most other pickers you can fuzzy search within the options. Selecting a directory with Enter opens a new file explorer under that directory and selecting a file opens that file. This is useful for examining a directory as a hierarchy. In contrast the usual file explorer (<space>f</code>) opens a picker with the contents of a directory recursively. For sprawling projects, the file explorer can be a more precise tool. LSP documentColors</h2> One of the flashier features of the Language Server Protocol (LSP) spec is the Document Color Request</a>. This request allows the client (Helix) to ask a language server like tailwindcss-language-server</code> or vscode-css-language-server</code> what ranges of the document correspond to RGB colors. In 25.07 Helix now requests document colors from language servers and displays the swatch (a small box) with the color, inline. This is exactly like the LSP inlay hints feature - which shows types - but for colors. </asciinema-player> New command mode features</h2> Command mode (:</code>) is used to execute typable commands. :write</code> is a typable command, for example, that takes an optional argument. So is :quit</code> - which takes no arguments. The syntax for command mode is nuanced. It should be simple so that common operations like :write path/to/doc.md</code> are easy to type. But it also needs tools for escaping spaces like in :write 'a b.txt'</code>. And for some commands it's useful to have a custom or extensible syntax, like :run-shell-command <complex shell-specific command></code>. 25.07 includes a complete rewrite of all of the code used to parse and represent arguments and provide completions for the command line. This fixes a number of bugs with parsing and completion, like trying to complete files with spaces in their names, and introduces two new features, flags and expansions. Flags</h3> Flags work just like flags you'd pass in a shell command. They're meant to cover cases where you want to execute a command with a minor modification in behavior. So far flags are only used for a small set of commands: the :write</code> family of commands (any command starting with :write</code>) and :sort</code>. 25.07 removes the :rsort</code> command and replaces it with :sort --reverse</code>, or :sort -r</code> for short. And the :write</code> commands now all accept a --no-format</code> flag. Typically you want to format the current document(s), if they're configured to auto-format, but occasionally it's useful to write the file exactly as-is. These are great use-cases for flags: you shouldn't need extra typable commands just to tweak small details. Flags are displayed in the infobox for typable commands and the long versions (like --reverse</code>) can be auto-completed. Expansions</h3> Expansions introduce a special syntax to interpolate values. These mostly follow Kakoune</a>'s concept of expansions with some minor tweaks. Variables based on the current editor state can be written as %{variable_name}</code>. %{buffer_name}</code> prints the name of the currently-focused document as it appears in the statusline, and %{cursor_line}</code> prints the 1-indexed line number of the primary cursor. Shell commands can be executed with the %sh{..}</code> expansion. Together with the variable expansions above and the new, simple :echo</code> command that prints to the statusline, a command like this prints the git blame of the current line on the statusline: :echo %sh{git blame -L %{cursor_line},+1 %{buffer_name}} </code></pre> Both variable names and expansion kinds (like sh</code> for shell commands or u</code> for Unicode) can be auto-completed. Extensible parsing</h3> The initial reason to explore this rewrite was to revisit how the command line was parsed. With the changes in 25.07, command mode parses and completes file names better, allows for flags and expansions, and also enables switching to other methods of parsing part-way through the line. Typable commands :set-option</code> and :toggle-option</code> now use serde_json</code>'s streaming deserializer</a> to parse complex config values like lists. Shell commands like :run-shell-command</code> and :pipe</code> no longer try to parse the command line after the command name. So you don't need to guess how to escape Helix's parsing rules and then your shell's parsing rules - the ultimate quote hell. Tree-house</h2> In this release cycle we switched out the crates we use to interact with Tree-sitter, adding new crates built from the ground up and removing the official bindings alongside a lot of old code from Helix. The rest of this post will discuss details about Tree-sitter and Tree-house. Looking for more details about the changes since Helix 25.01.1? Check out the changelog</a> for the full set of code changes. Tree-sitter</h4> Not familiar with Tree-sitter</a>? At a high level, it's a framework for generating and using fast, error-tolerant parsers. In a grammar.js</code> file you can write parser rules via the Grammar DSL</a> and use then use tree-sitter</code> CLI tools to generate and test the parser. Tools like editors can then use the parser you've defined with the Tree-sitter C library, or language specific bindings, to parse and act on syntax trees. What you do with the syntax tree is up to your imagination! Language servers can use Tree-sitter for their parsers, diff tools like Difftastic</a> can produce syntax-aware diffs, a language server like Codebook</a> can do a syntax-aware scan for spell checking. Even GitHub uses tree-sitter</a> for code navigation and highlighting of some languages. A very powerful tool for working with parsed trees is Tree-sitter queries. Queries are a way to pattern-match against subtrees and capture nodes for future use. For an editor you might use a query, commonly called highlights.scm</code>, to capture a tree node like a Rust keyword in order to highlight the node's text according to the current theme. Like syntax trees, the applications for queries are only limited by your imagination. We currently use queries in Helix for highlighting, indentation and textobjects (recognizing functions, parameters, etc.). In the future, code folding, spell checking and code navigation could use tree-sitter queries as well. History in Helix</h4> Helix depended on Tree-sitter for syntax highlighting even before its initial public release via the official Rust bindings to the C library, the tree-sitter</code></a> crate. The tree-sitter</code> crate wraps the C library and is fairly low level. We also need a highlighter and that is provided by a separate crate: tree-sitter-highlight</code>. tree-sitter-highlight</code></a> provides a syntax highlighter which takes the queries for a language and a document's text to highlight and can be iterated to produce highlight events. Helix could then consume highlight iterators while rendering the viewable documents. This works out-of-the-box with tree-sitter-highlight</code> and for our simple use-cases like highlighting a document once, tree-sitter-highlight</code> is all you need. The problem with tree-sitter-highlight</code> is that it doesn't work incrementally. Creating a new highlight iterator means fully re-parsing the document as well as re-analyzing the queries. This is wasteful since Tree-sitter can reuse queries. Plus parsing in Tree-sitter can work incrementally: you can give the old syntax tree to Tree-sitter and it will parse the new version of the document faster. So Helix's early highlighter was a fork of tree-sitter-highlight</code>, inspired by Tree-sitter's use in the Atom editor</a>, which factored out the parsed tree (a Syntax</code> type) and tree_sitter::Query</code>s from the highlighter. Ideally we wanted to extract this highlighter into its own crate one day so we could share it easily with other tools. This highlighter grew to become unmaintainable, though. Fixes for longstanding bugs were too large to make or completely incompatible with this highlighter's design and the code was hard to reason about. Enter Tree-house</h4> With this release we've replaced the highlighter with a new crate: tree-house</code></a>. We wrote Tree-house from scratch based on our experience with those early highlighters. Tree-house leans into the things that worked well like separating parsing from querying and determining injections during parsing. And it leans away from the things that didn't work well, like exposing highlights as an Iterator</code>. The Tree-house code is broken down into smaller and more understandable components and it squashes longstanding bugs that we were powerless to solve before. Tree-house also opens the door for future improvements like parallel parsing. Tree-house's main strength is its robust handling of a feature called injections. Injections, a tree of trees</h4> Injections are a concept from tree-sitter-highlight</code>. Injection queries capture nodes which should 'switch' to another language. For example in Markdown, you can use a code-fence like so: ```rust println!("Hello, world!") ``` </code></pre> And you would expect the contents of that code-fence to be highlighted as Rust code. How this works is that the full text of this Markdown document is parsed using a Markdown Tree-sitter parser. An injections.scm</code> query for Markdown tells Helix that the contents of this code-fence should be treated as Rust code instead. Then Helix runs a Rust Tree-sitter parser for that range of the document and creates a syntax tree. Then when it comes time to highlight this document, the highlights.scm</code> query for Markdown defines highlights for the Markdown parts. And when we get to the Rust layer of the document, the Rust highlights.scm</code> take over. While this is a simple example, injections can work robustly even in complicated cases. This release adds support for Markdown injection within Rust's doc comments for example, leading to deeply nested injections like this: /// A type that parses **stuff** /// /// This is a doc comment, so it should have _Markdown_ highlighting /// on top of the regular comment highlights. /// /// # Heading 1 /// /// Know what we can do with Markdown? Inject Rust! /// /// println!("Hello, world!"); pub struct Parser(/* ... */); </code></pre> In a Rust file like this, the root layer covering the full document is Rust, naturally. Then each doc line comment (///</code>) has the content past it parsed as a Markdown document, combined - meaning that the ranges are collectively treated as one Markdown layer. And nested within that, the indented block should act like a code-fence which is another Rust layer. Internally Tree-house represents this layer concept as a tree. The overall Syntax</code> type has a root layer for its file type, and children layers under that for all of its injections. And the children layers can inject other layers themselves, and so on. So the layers form a tree. And each layer is parsed so that it has its own syntax tree, making a kind of tree of trees. Incremental injections</h4> Injections were previously discussed way back in the 22.03 release notes</a> which added support for combined injections, like those Markdown comments. Later that year, 22.12</a> brought incremental injections. That change reduced the unnecessary work done to re-parse and rerun injections queries for documents with many injections. The switch to Tree-house improves upon incremental injections so that injection layers are re-parsed and injection queries are rerun only for layers which actually changed from any set of edits. For a more intuitive idea of how this works, imagine a large Markdown list. The Markdown Tree-sitter parser is actually split into two: one for block syntax like code fences and another for "inline" syntax like bold, italics and inline code. The Markdown parser injects the "inline Markdown" parser for situations like list items, so a very large list in Markdown means thousands of small injections of the "inline" parser for each list item. With the switch to Tree-house, editing within one list item in a large list will only cause the re-parsing and rerun of injections queries for root layer and the edited "inline" layer - the minimum amount of work required. Locals</h4> Another useful concept from tree-sitter-highlight</code> is locals. locals.scm</code> is a query used to tag nodes which should have their highlight applied to any later references within the same scope. Imagine a simple Rust function: fn add(a: usize, b: usize) -> usize { a + b } </code></pre> The a</code> and b</code> parameters to this function should be highlighted as parameters - possibly a different highlight depending on the theme. To track this information, the locals query captures nodes for function parameters like a</code> and b</code> and also the scope: the function body in this case. Any references - also captured by the locals query - within the scope should inherit the definition's highlight. Tree-house takes a different approach to locals which solves a longstanding bug in Helix. Since the highlighter is only run for the small range you can see on your screen, locals disappeared whenever the definition fell out of view. </asciinema-player> Notice how the parameters slice</code>, char_idx</code> and n</code> lose their parameter highlight (underlined) when the parameters go out of view. With Tree-house, the definitions are tracked at parse-time and stored in a tree format, like injections, for fast lookup. So the current view of the code doesn't make a difference. Parameters are highlighted correctly regardless of whether the definition is within view. </asciinema-player> Now slice</code>, char_idx</code> and n</code> parameters keep their highlight no matter how far into the function you go. Injections for all</h4> One of the nicer quality-of-life improvements brought by Tree-house is that Tree-house's Syntax</code> type - corresponding to a parsed document - has functions for working across injections smoothly. Syntax</code> is organized as a tree of trees, so looking up injection layers is done in logarithmic time rather than a full scan of all layers. Building on this, a TreeCursor</code> type mirroring the TreeCursor</code> from Tree-sitter C library moves across injection layers with an API nearly identical to Tree-sitter's TreeCursor</code> API. A new QueryIter</code> type provides the ability to run any query across all injection layers in the document - not just highlights. Taking advantage of injections for all Tree-sitter based features will lead to a more consistent experience across language boundaries. Comment tokens and textobjects within an HTML <script></code> tag should follow JavaScript rules rather than HTML. Indentation within a Markdown code-fence should follow the language you're writing out, not Markdown. These features are not yet merged or released but eventually all Tree-sitter based Helix features should behave as consistently as highlighting. Wrapping up</h2> These has been the highlights from the 25.07 release plus a deeper dive into our Tree-sitter integration. Check out the full changelog</a> for the details. Come chat about usage and development questions in the Matrix space</a> and follow along with Helix's development in the GitHub repository</a>.



Release 25.01 Highlights
2025-01-03T00:01:00+00:00
The new year brings in a new Helix release! Say hello to 25.01. This is an
especially large release comprising changes from a whopping 171 contributors.
Thank you</em> to everyone who made this release possible!</p>
New to Helix?
Helix is a modal text editor with built-in support for multiple selections,
Language Server Protocol (LSP), tree-sitter, and experimental support for Debug
Adapter Protocol (DAP).</p>
This large release has a bunch of big improvements so let's jump right in to
the highlights.</p>
Completions</h2>
Completions have seen two big updates in 25.01. First, completions now support
paths:</p>
</asciinema-player>
Helix now detects a possible path when inserting text and suggests either
absolute paths or relative paths based on the current working directory. This
is especially useful for some languages like Nix where paths are commonplace.</p>
Path completion is especially exciting because it's the first completion
feature not driven by LSP. The change to add path completion refactored parts
of the codebase that assumed that completions could only ever come from a
language server and this should make it easier to add new completion sources
in the future.</p>
The other big change comes to the behavior of snippet completions - currently
only sent by language servers - as 25.01 adds support for snippet tabstops.</p>
</asciinema-player>
In the recording above, rust-analyzer suggests a snippet completion for add</code>
that includes some placeholders for the function arguments. In the past Helix
would clear these placeholders when accepting the completion with the Enter
key. Now the Enter key jumps the cursor to the first tabstop. The Tab key can
be used to switch to the next tabstop. Typing in any other character replaces
the placeholder text.</p>
Diagnostics</h2>
Historically, LSP diagnostics have appeared right-aligned in the top-right
corner of the editor. While this display is straightforward, it can become hard
to read on small terminal sizes or when a language server sends a long
diagnostic message. 25.01 adds a new way to render diagnostics inline</em>.</p>
</asciinema-player>
Inline diagnostics leverage the internal virtual text system to render
diagnostics at the diagnostic's range in the document. Diagnostic messages
appear after the end of the line or in between lines of the appropriate code.</p>
Inline diagnostics are currently disabled by default as we tune the display and
iron out bugs and can be enabled with a config like so:</p>
# ~/.config/helix/config.toml
</span>[editor]
</span># Minimum severity to show a diagnostic after the end of a line:
</span>end-of-line-diagnostics </span>= "</span>hint</span>"
</span>
</span>[editor.inline-diagnostics]
</span># Minimum severity to show a diagnostic on the primary cursor's line.
</span># Note that `cursor-line` diagnostics are hidden in insert mode.
</span>cursor-line </span>= "</span>error</span>"
</span># Minimum severity to show a diagnostic on other lines:
</span># other-lines = "error"
</span></code></pre>
Setting end-of-line-diagnostics</code>, cursor-line</code> or other-lines</code> to anything
other than "disable"</code> enables inline diagnostics.</p>
Tabular pickers</h2>
The picker UI component is central in Helix: it's an efficient and readable way
to jump between files and locations of interest like LSP diagnostics and
symbols. In 25.01 the picker component has been overhauled significantly so
that items are laid out as a table.</p>
</asciinema-player>
Simple pickers such as the file picker (<space>f</code>) which only need one column
are unchanged. Pickers with multiple fields of information though now show
column names at the top of the the results pane. Rows still correspond to
individual items to pick but there are now columns that horizontally align
the same kinds of content between items. The diagnostics picker for example now
has three columns - "severity", "code" and "message" - while the LSP symbol
picker has two - "kind" and "name".</p>
Columns are individually filterable: one column is filtered by default and
others can be filtered with a query syntax: %<column name> filter text</code>. For
example the diagnostics picker can now be filtered down to only errors by
searching for %severity error</code>. Filter text is fuzzy matched and column names
may be specified by a prefix, so a search for %s e</code> will behave the same in
the diagnostics picker as a search for %severity error</code>.</p>
</asciinema-player>
Alongside this change, the global_search</code> command (<space>/</code>) has been
refactored to update with the picker's query dynamically. This allows searching
a codebase for a regex interactively. Filenames can then be filtered separately
with a query like %path filename</code>.</p>
Macro keybindings</h2>
Initial support for keybindings written as macros has landed in 25.01. Macro
keybindings can be written by prefixing a string of inputs with @</code>.</p>
# Change the `<space>y` keybinding to yank to the `a` register instead of the
</span># system clipboard:
</span>[keys.normal]
</span>space</span>.</span>y </span>= "</span>@</span>\"</span>ay</span>"
</span></code></pre>
Macro keybindings use the same infrastructure as macros recorded with q</code> and
executed with Q</code>, so the above behaves as if you typed</p>

"</code>: open the register select popup</li>
a</code>: select the 'a' register</li>
y</code>: copy the selection contents to the register</li>
</ol>
Macros cover a gap in keybindings: inputs into components like the register
select popup are not exposed as commands, so operations like selecting a
register would not otherwise be possible to bind.</p>
The initial support for macro keybinding limits the bindings to be unusable
in a command sequence: you can't yet combine macros with regular commands. For
example you could swap out the y</code> above for its command yank</code> in a sequence
like ["@\"a", "yank"]</code>, but this is not yet supported.</p>
Commenting</h2>
25.01 includes improvements to commenting that make for a smoother experience
when writing line comments like inline documentation.</p>
</asciinema-player>
Line comments are now continued by default: pressing the Enter key while in
insert mode or o</code>/O</code> in normal mode while the cursor is on a line comment now
extends that comment, inserting the current comment token prefix and a trailing
space character. Trailing whitespace is now consistently stripped when pressing
Enter, so <ret><ret></code> can be used to insert a break between two paragraphs in
inline markdown documentation for example.</p>
The join_selections</code> and join_selections_space</code> commands (J</code> and A-J</code>) have
also been improved to now strip the comment token when combining line comments.
This makes it easier to edit existing comments or fix spacing between
paragraphs.</p>
Wrapping up</h2>
As always, this is just the highlights from the 25.01 release. Check out the
full changelog</a> for the details.</p>
Come chat about usage and development questions in the Matrix space</a>
and follow along with Helix's development in the GitHub repository</a>.</p>


Release 24.03 Highlights
2024-03-30T00:00:00+00:00
The Helix 24.03 release has arrived! First, a very big thank you</em> to everyone
who made this release possible. This release saw changes from 125 contributors.</p>
New to Helix?
Helix is a modal text editor with built-in support for multiple selections,
Language Server Protocol (LSP), tree-sitter, and experimental support for Debug
Adapter Protocol (DAP).</p>
Let's check out this release's highlights.</p>
Amp-like jumping</h2>
</asciinema-player>
Jumping features are popular in the (Neo)Vim plugin space and there are even
plugins to add the same functionality to other tools like browsers. They allow
you to move your selection efficiently across even large parts of the view,
like you could by clicking with a mouse, but by entering "labels" instead.
24.03 introduces jumping commands inspired by the Amp editor</a>'s jump mode</a>.
Press gw</code> to add the jump labels and then enter one of the labels to jump to
the word under that label. Using gw</code> in select mode (v</code>) extends the
selection.</p>
Block comments</h2>
In the past, Helix has only been able to toggle line comments like //</code> and #</code>
and languages like OCaml have been left with workarounds like a "line" comment
token of (*</code>. In 24.03 Helix can now toggle block comments as well. Use C-c</code>
or <space>c</code> to smartly add or remove line or block comments around the current
selection based on the language's comment token configuration, <space>c</code> to
toggle block comments around the current selection, or <space><A-c></code> to toggle
only line comments on the current line.</p>
Improvements to tree-sitter injections</h2>
Helix uses tree-sitter</code></a> incremental parsing for syntax highlighting,
textobjects, indentation and some motions and commands. 24.03 improves how we
handle injections</a></em> - a powerful tree-sitter feature for parsing documents
with multiple languages. For example you might have JavaScript, CSS or other
languages within a <script></code> or <style></code> tag in HTML. The HTML parser doesn't
need to know how to parse all of these languages. Instead it can inject</em>
JavaScript or CSS parsers to handle the <script></code> or <style></code> tag contents.</p>
</asciinema-player>
One of these improvements is to the :tree-sitter-subtree</code> command that
displays an S-expression of the syntax tree under the cursor. 24.03 shows the
injection layer under the selection instead of only the root layer. For example
in this asciicast we now show the syntax tree for the JavaScript parts of the
document while in the past we only showed the HTML part of the tree.</p>
The other big improvement is to the tree-sitter motions. A-o</code> (alt + o)
expands the selection to the parent node of the syntax tree node covered by the
current selection. A-i</code> shrinks to the child node and A-n</code> and A-p</code> go to
the n</em>ext and p</em>revious nodes, respectively. Previously these
commands only worked on the root layer (for example HTML in the asciicast) but
they now find the injection layer that contains the selection and move along
that layer's syntax tree. Internally we organize injection layers into a
tree-like structure so that these motions can switch layers when needed.</p>
Stay tuned for future changes that improve injections, like finding textobjects
within injected content.</p>
Internal improvements</h2>
24.03 also saw major internal improvements. The first comes from a new "event
system" - a system built around Tokio channels and tasks that allows different
parts of the Helix codebase to communicate with one another. The event system
also adds generic ways to debounce and run tasks in background threads so we
can prevent locking up the UI. Some parts of the code base have already been
migrated to the event system like LSP completion and signature-help. In
24.03 you'll notice that LSP completion doesn't automatically pop up after just
navigating around in insert mode, for example with arrow keys. It's now hooked
into document changes instead, so it can smartly pop up when you start changing
a document rather than every time the editor goes idle.</p>
The other major improvement to be excited for is the general replacement of the
regex</code> crate with regex-cursor</code></a>, a streaming regex implementation
compatible with ropey</code></a>, the rope crate we use to represent all documents.
regex-cursor</code> is capable of running on discontiguous strings</em> - input that
may not be collocated in memory. In a rope, different parts of the document
might be stored separately internally. To use the regex</code> API we needed to
convert slices of the document to a regular Rust String</code>, duplicating the
memory footprint of that slice of the document. regex-cursor</code> operates on the
chunks of the rope instead, which greatly improves efficiency.</p>
Wrapping up</h2>
As always, this is just the highlights from the 24.03 release. Check out the
full changelog</a> for the details.</p>
Come chat about usage and development questions in the Matrix space</a>
and follow along with Helix's development in the GitHub repository</a>.</p>


Release 23.10 Highlights
2023-10-25T00:00:00+00:00
The Helix 23.10 release is finally here! 23.10 introduces some very large
internal changes that enable some powerful features. A very big thank you</em> to
everyone who made this release possible.</p>
New to Helix?
Helix is a modal text editor with built-in support for multiple selections,
Language Server Protocol (LSP), tree-sitter, and experimental support for Debug
Adapter Protocol (DAP).</p>
Let's check out this release's highlights.</p>
Multiple language servers</h2>
23.10 brings a big change to the way we handle language servers.
Previously each language could only support one language server at a time but
now you can configure multiple to work in tandem. For example you might use
the TypeScript language server for JavaScript/TypeScript development and also
configure efm-langserver</a> for
Prettier formatting and ESLint diagnostics. With the new support for multiple
language servers, you can specify which features to use from each language
server.</p>
This brings a big change to the way language servers are configured in your
language configuration (languages.toml</code>). All language servers are now
specified separately from languages and then each language selects which
language server(s) to use. From the example above, you might configure efm-
langserver and typescript-language-server like so:</p>
[language-server.efm]
</span>command </span>= "</span>efm-langserver</span>"
</span>config</span>.</span>documentFormatting </span>= </span>true
</span>
</span>[language-server.typescript-language-server]
</span>command </span>= "</span>typescript-language-server</span>"
</span>args </span>= ["</span>--stdio</span>"]
</span>config</span>.</span>hostInfo </span>= "</span>helix</span>"
</span>
</span>[[language]]
</span>name </span>= "</span>typescript</span>"
</span>auto-format </span>= </span>true
</span>language-servers </span>= [
</span>  { </span>name </span>= "</span>efm</span>", </span>only-features </span>= ["</span>format</span>", "</span>diagnostics</span>"] },
</span>  { </span>name </span>= "</span>typescript-language-server</span>", </span>except-features </span>= ["</span>format</span>", "</span>diagnostics</span>"] },
</span>]
</span></code></pre>
See more details in the language configuration docs</a>.</p>
Fuzzy matching with Nucleo</h2>
</asciinema-player>
Helix uses "fuzzy" matching to filter as-you-type in components like the file
picker. Previously we used the popular skim</code>/fuzzy-matcher</code> crates but in the
23.10 release we've switched to the new
nucleo</code></a> crate. Nucleo is
significantly faster than skim and fzf, handles Unicode correctly, and uses a
bonus system that feels more intuitive.</p>
Nucleo also enables us to lazily stream in new items, which is a big boost for
the user experience for pickers. In the asciicast above I'm scanning through
my computer's /nix/store</code>, a huge directory containing more than twenty
million files. The file picker now works gradually as we scan through the
directory and matches files as we find them.</p>
Nucleo also paves the way for future picker upgrades. Stay tuned to the
upcoming release notes to see where we'll take the picker.</p>
Smart tab</h2>
Smart tab is a new feature bound to the tab key in the default keymap. When
you press tab and the line to the left of the cursor isn't all whitespace,
the cursor will jump to the end of the syntax tree's parent node. For example:</p>
{
</span>  </span>key </span>= "</span>value</span>";
</span>  </span>nested </span>= {
</span>    </span>key2 </span>= "</span>value2</span>"; </span># When the cursor is at the end of the line here, <tab>
</span>                     </span># jumps right after the closing brace on the next line.
</span>  };
</span>}
</span></code></pre>
This is useful in languages like Nix for adding semicolons at the end of an
attribute set or jumping to the end of a block in a C-like language:</p>
</asciinema-player>
Expanded support for registers</h2>
</asciinema-player>
Registers allow you to save and paste values. For example you might select
a paragraph, use "ay</code> to yank it into the a</code> register, and later use "ap</code>
to paste that paragraph. Some registers have special effects when read or
written to though like the _</code> "blackhole" register: any values written are
discarded and nothing can be read. Special registers have been expanded to
include some useful ones from Kakoune and clipboard registers:</p>

%</code>: the current buffer name</li>
#</code>: the number of each selection, 1-indexed</li>
.</code>: the contents of each selection</li>
*</code> and +</code>: system and primary clipboards</li>
</ul>
Also check out the new register statusline element. It appears when you select
a register with "</code>. Notice the reg=#</code> in the bottom-right corner of the
statusline in the asciicast when we select the #</code> register and how it goes
away when we paste that register (p</code>) or increment the selections (C-a</code>).</p>
Initial support for LSP DidChangeWatchedFiles</h2>
</asciinema-player>
Some language servers use the DidChangeWatchedFiles notification to discover
changes to related files in other languages. For example, rust-analyzer</code> will
fetch and index new dependencies when you add them to your Cargo.toml</code>.
Helix will now send file change notifications when the file is changed by
Helix itself. Full support for DidChangeWatchedFiles will require a file
watcher but for now we're able to support the most common use-case for
DidChangeWatchedFiles.</p>
Syntax highlight regex prompts</h2>

Regex prompts like those created with s</code>, S</code> or |</code> are now syntax highlighted
via tree-sitter-regex. The highlighting makes special characters more obvious
and can catch syntax errors like trailing backslashes.</p>
Wrapping up</h2>
As always, this is just the tip of the iceberg for the 23.10 release. Check out
the changelog</a> for the full details.</p>
Come chat about usage and development questions in the Matrix space</a>
and follow along with Helix's development in the GitHub repository</a>.</p>


Release 23.03 Highlights
2023-03-31T00:00:00+00:00
Helix is a modal text editor with built-in support for multiple selections,
Language Server Protocol (LSP), tree-sitter, and experimental support for Debug
Adapter Protocol (DAP).</p>
Today marks the 23.03 release. First, a big thank you</em> to everyone involved!
This release includes changes from 102 contributors. Today's release brings
some especially useful and exciting features, so let's jump right in.</p>
Soft-wrap</h2>
</asciinema-player>
Soft-wrap breaks up lines to fit in view without inserting actual line break
characters into the text (so called "hard-wrapping"). This can be useful for
reading and editing documentation or code with especially long lines. Enable
soft-wrap in your config with the editor.soft-wrap.enable</code> key:</p>
# ~/.config/helix/config.toml
</span>[editor.soft-wrap]
</span>enable </span>= </span>true
</span></code></pre>
Heuristics for where to break lines and the wrap indicator may also be
configured</a>.</p>
Soft-wrap is the first feature implemented on top of a new "virtual text" API
within the Helix codebase. The virtual text API allows us to decorate and
manipulate the actual text in a document without disturbing positioning and
modifications. The virtual text API opens the door for many new exciting
features like the inlay hints we'll see next.</p>
Inlay hints</h2>
</asciinema-player>
Inlay hints are a new feature in the latest LSP specification. Language servers
can provide editors with hints to show in a document. In the example above,
rust-analyzer provides type hints for variables and intermediary expressions
as well as parameter names in function calls.</p>
Inlay hints can be enabled in your config with the lsp.display-inlay-hints</code>
key.</p>
Initial support for snippets</h2>
</asciinema-player>
LSP snippets are a way for language servers to provide more complex completions
for an editor. Language servers can specify where to place cursors within a
completion (tabstops), placeholder values and more. Helix now has initial
support for LSP completions, leaving more advanced snippet features like
virtual placeholders, multiple tabstops, and variable substitutions for future
work.</p>
Dynamic workspace symbol picker</h2>
</asciinema-player>
The workspace symbol picker (<space>S</code>) is an LSP-driven feature for looking
up a symbol in a project. Large projects might have many symbols, though, so
this symbol picker typically wouldn't load them all at once. The workspace
symbol picker has been reworked in this release though to dynamically
re-request symbols with a new query as you type in the picker. This lets the
language server narrow down the number of symbols and only tell Helix about the
ones relevant to the search. This rework fixes compatibility with some language
servers which returned empty symbols with no query (gopls</code>, pyright</code>,
clangd</code>) or limited results (rust-analyzer</code>).</p>
The "dynamic picker" introduced in this refactor may benefit other pickers in
the future, for example allowing the global search picker (<space>/</code>) to
update on-the-fly as you change the query.</p>
Version control HEAD statusline element</h2>
</asciinema-player>
A new statusline element has been added which displays the version control
HEAD. Add this to your statusline by introducing the "version-control"</code>
element in the
editor.statusline</code></a>
section of your config for the left</code>, center</code> or right</code> sides.</p>
Enhanced keyboard protocol</h2>
Support for the enhanced keyboard protocol</a> is now enabled. Terminals that
support the protocol (Kitty, WezTerm) can now send unambiguous keycodes to
Helix, enabling key combinations that weren't possible to bind before like
C-/</code>, C-h</code> or S-backspace</code>. This functionality works out-of-the-box for
terminals that support the protocol.</p>
Runtime directory refactor</h2>
Helix keeps files like tree-sitter parsers and queries, themes and the tutor
file in a special "runtime" directory. This directory is typically installed
by your package manager and shouldn't be modified by hand. Multiple runtime
directories are now supported, so you can keep the runtime files installed by
your package manager unchanged while adding new tree-sitter parsers and
queries to a local runtime directory. On Unix systems you can add files to the
~/.config/helix/runtime</code> directory which take precedence over the runtime
directory installed by a package manager.</p>
Wrapping up</h2>
These flashy features are just the tip of the iceberg though. Check out the
23.03 changelog</a> for the full details on all of the changes in this release.</p>
Come chat about usage and development questions in the Matrix space</a>
and follow along with Helix's development in the GitHub repository</a>.</p>


Release 22.12 Highlights
2022-12-06T22:00:00+00:00
Helix is a modal text editor with built-in support for multiple selections,
Language Server Protocol (LSP), tree-sitter, and experimental support for Debug
Adapter Protocol (DAP).</p>
Today we cut the 22.12 release. This release is big and featureful and saw
contributions from 99 contributors. Thank you all! 🎊</p>
Helix now has a logo! Thank you @jakehl</code></a> for your
contribution!</p>

Looking for an introduction to Helix or to see Helix out in the wild? Check out
these new videos on Helix.</p>

https://www.youtube.com/watch?v=xHebvTGOdH8</a></li>
https://www.youtube.com/watch?v=7mTi278jUS8</a></li>
</ul>
Now let's jump into the highlights.</p>
Git diff gutter</h2>
</asciinema-player>
The new git diff gutter tracks the changes in the current buffer compared to
the the git index. The markers in the gutter indicate additions, modifications,
and removals compared to the file checked in to git. The git diff gutter is
enabled by default.</p>
Also be sure to try out the new hunk textobject: ]g</code> jumps to the next changed
hunk and [g</code> jumps to the previous.</p>
Underline styles and colors</h2>

Terminals with support for extended underlines can render underlines with
styles like curls or dots as well as colors. Extended underlines can be used to
improve the display of LSP diagnostics. These can be configured in themes with
the new underline</code> key:</p>
"</span>diagnostic.error</span>" = { </span>underline </span>= { </span>style </span>= "</span>curl</span>", </span>color </span>= "</span>red</span>" } }
</span></code></pre>
The existing underline</code> modifier is now an alias for the "line"</code> style.</p>
If you're looking to use this in a theme that hasn't configured it yet, you
can use the new theme inheritance</a> feature to modify just the scopes you would
like to change:</p>
# ~/.config/helix/themes/my-onedark.toml
</span>inherits </span>= "</span>onedark</span>"
</span>
</span>"</span>diagnostic.error</span>" = { </span>fg </span>= "</span>errorfg</span>", </span>bg </span>= "</span>errorbg</span>", </span>underline </span>= { </span>color </span>= "</span>red</span>" } }
</span></code></pre>
Autosave when the terminal loses focus</h2>

Terminals with support for focus events can now automatically save the current
file when you focus on a new window. Enable this behavior by setting the
editor.auto-save</code> configuration key to true</code>.</p>
Multi-cursor completion</h2>
</asciinema-player>
Editing with multiple selections is a central feature within helix. LSP
auto-completion now applies to all cursors when editing with multiple
selections, making it easy to replace multiple instances of a symbol with
auto-complete's help.</p>
Bufferline</h2>
</asciinema-player>
The bufferline is a listing of buffers displayed at the top of a window. It
provides an at-a-glance view of the buffers you're working with. Set
the editor.bufferline</code> configuration key to "always"</code> to always show the
bufferline, "multiple"</code> to show the bufferline only when there are multiple
buffers open, and "never"</code> to disable it.</p>
Behind-the-scenes improvements</h2>
22.12 brings also brings important changes to Helix's plumbing:</p>

The code-path for writing files has been overhauled. This fixes a number of
edge cases around writing large files and failures to write.</li>
Performance has been improved for tree-sitter parsing, querying and the
handling of injections. This is a noticeable speed boost for large markdown
files in particular since markdown uses injections extensively.</li>
Failure handling in the LSP code-paths has been improved. Helix now
gracefully handles cases like language servers not supporting capabilities
and unexpected language server crashes.</li>
The speed and memory usage of the :reload</code> command has been vastly improved.
This comes from the creation of imara-diff</code></a>, a new diffing
implementation which is faster than the one used internally by git</code>!</li>
</ul>
Wrapping up</h2>
There are many more changes arriving now in 22.12 than we can fit in this post.
Check out the 22.12 changelog</a> for the full details on all of the performance
boosts, usability improvements and fixes in 22.12.</p>
Contribute and follow along with development in the Helix GitHub
repository</a> and be sure to join in on discussions in the Matrix
channel</a>.</p>


Release 22.08 Highlights
2022-08-31T18:00:00+00:00
Helix is a modal text editor with built-in support for multiple selections,
Language Server Protocol (LSP), tree-sitter, and experimental support for Debug
Adapter Protocol (DAP).</p>
Today marks the 22.08 release, a release with plenty of fixes and new features.
A big thank you</em> to our contributors! This release had 87 contributors. 🎉</p>
Let's check out the highlighted features for 22.08.</p>
Indent guides</h2>
</asciinema-player>
Indent guides provide a visual representation for the current indentation
level. Enable indent guides with the editor.indent-guides.render</code> key.
The character used as a guide is also customizable.</p>
Cursorline</h2>
</asciinema-player>
The cursorline is a horizontal highlighted bar that follows your cursor.
Cursorlines may be themed for the primary and all secondary cursors and
can be enabled or disabled separate from theming with the editor.cursorline</code>
option.</p>
Mode colors</h2>
</asciinema-player>
The mode indicator in the statusline may now be styled based on the current
mode. This feature may be enabled with the editor.color-modes</code> option and
colors may be configured using ui.statusline.{insert,normal,select}</code> keys
in themes.</p>
Configurable statusline</h2>
</asciinema-player>
The statusline may now be configured in the editor.statusline</code> section
of the config. Elements may be placed on the left, center or right of
the statusline with a configurable separator and spacers. Two new elements
may now also be added to your statusline: file-line-ending</code> and
position-percentage</code>.</p>
LSP signature help</h2>

Signature help provides documentation as you type the arguments to a function
call and tracks which function parameter is currently being entered. Signature
help is enabled by default.</p>
LSP document highlight</h2>
</asciinema-player>
The document highlight request (Space-h</code>) creates a selection for all
instances of the symbol under the primary cursor. Helix has robust support for
multiple selections, so you may edit all selections simultaneously (for
example with c</code>) or cycle between selections ((</code>/)</code>).</p>
LSP diagnostics pickers</h2>
</asciinema-player>
The new buffer and workspace diagnostics pickers may be used to jump to
Language Server diagnostics like warnings and errors. Use Space-g</code> to
open the picker with diagnostics for the current buffer and Space-G</code>
to view all diagnostics in a workspace.</p>
Jumplist picker</h2>
</asciinema-player>
The jumplist saves a history of selections. Save selections with C-s</code> and jump
forward with C-i</code> and backward with C-o</code>. The jumplist is a powerful tool,
especially when working with Language Server goto-definition or global search
which both save to the jumplist automatically.</p>
22.08 adds a new picker that can be used to jump across entries in the jumplist.
The preview pane shows the line of the saved primary selection. Bring up the
jumplist picker with Space-j</code>.</p>
External formatters</h2>
</asciinema-player>
Many Language Servers provide format-on-save capabilities. For languages
without Language Servers or for Language Servers that do not implement
formatting, an external formatter binary may now be configured. The document
is passed through the formatter's stdin and replaced with the formatted output
from stdout.</p>
An external formatter may also be used when you prefer the formatting from an
external tool over formatting provided by a Language Server. For example if you
configure black</code> for formatting Python, formatting will be accomplished with
black</code> rather than pylsp</code>.</p>
Bracketed paste</h2>
</asciinema-player>
Bracketed paste is terminal emulator feature that allows terminal programs to
recognize paste sequences and handle the pasted text. Without bracketed paste
support, text pasted with operating-system level paste (C-v</code>) looked to Helix
like text that was entered very quickly which lead to some odd side-effects
like awkward indentation or mysteriously appearing auto-pair characters.</p>
22.08 adds support for bracketed paste, so now all pastes into Helix from
terminal emulators that support bracketed paste work as if you had pressed
Space-p</code> in normal mode. In the above cast, the entire text of Moby-Dick</em>
is pasted with C-v</code> in insert mode instantly.</p>
Wrapping up</h2>
These changes are just the highlights. Check out the full changelog</a> to see
all that's changed since 22.05. Release binaries can be found on the release
page</a>.</p>
Be ready for more exciting changes in Helix 22.10 expected in October!
Contribute and follow along with development in the
Helix GitHub repository</a> and be sure to join in on discussions in
the Matrix channel</a>.</p>


Release 22.05 Highlights
2022-05-28T13:00:00+00:00
Helix is a modal text editor with built-in support for multiple selections,
Language Server Protocol (LSP), tree-sitter, and experimental support for Debug
Adapter Protocol (DAP).</p>
Today marks the 22.05 release, a featureful release with over double the number
of contributors as last release (110!). A big thanks to all involved! 🙌</p>
Also a big shout out to @amirrezaask</code></a> for
this great Helix introduction video</a>!</p>
Let's check out the flashy features of 22.05.</p>
Indentation rework</h2>
The indentation system has been fully reworked. Indentation still works by
querying the parsed tree-sitter syntax tree for a document, but now query files
can use the full expressive power of tree-sitter queries rather than just
simple node names. Expect more robust indentation with fewer edge cases.</p>
Configurable gutters</h2>
Gutters can now be configured in your config.toml</code> file. For example, you can
remove the line-number gutter while still showing LSP diagnostics.</p>
[editor]
</span>gutters </span>= ["</span>diagnostics</span>"] </span># default is ["diagnostics", "line-numbers"]
</span></code></pre>
Local language configuration</h2>
Language configuration can now be specified local to a project. Create a
.helix</code> directory and a languages.toml</code> under it to override values from the
default language configuration</a>. For example, override a C project's indents
to use tabs instead of spaces for indentation:</p>
# my_c_project/.helix/languages.toml
</span>[[language]]
</span>name </span>= "</span>c</span>"
</span>indent </span>= { </span>tab-width </span>= </span>8</span>, </span>unit </span>= "</span>\t</span>" }
</span></code></pre>
Rulers</h2>
</asciinema-player>
Vertical rulers may now be configured through the rulers</code> option. Use them
as a guide when adhering to a maximum line length.</p>
Show visible whitespace</h2>
</asciinema-player>
Whitespace characters like spaces, tabs, and newlines may now be rendered. Use
the whitespace.render</code> option either at runtime with the :set</code> command or in
your config.toml</code> under the editor section. Visible whitespace indicators can
make Helix's selection model more intuitive, especially around line endings.
The characters used for tabs, spaces, non-breaking space, and newlines may also
be customized as well as whether any of the characters are rendered at all. In
fact, for the remaining asciicasts in this post, you'll be seeing my custom tab
and newline characters!</p>
Use registers in prompts</h2>
</asciinema-player>
Values stored in registers may now be used in prompts like search or global
search. In the above example, we yank a selection to the "</code> register with
y</code> and then open up the global search prompt with Space</code> /</code>. The available
registers are shown above the prompt and we hit "</code> to insert the contents of
the "</code> register.</p>
Reflow paragraphs</h2>
</asciinema-player>
The new :reflow</code> command hard-wraps text to a given column width. Default
column widths may be configured on a per-language basis. Reflow recognizes
matching prefixes between lines, so you may reflow line-comments, markdown
quotes or lines with leading whitespace and the leading characters will be
placed appropriately.</p>
Swap windows</h2>
</asciinema-player>
Windows may now be swapped with neighbor windows and splits may be transposed.
With the window menu open (C-w</code> or space w</code>), use H</code>, J</code>, K</code>, and L</code>
to swap the current window with the left, down, up, and right neighbors,
respectively. Use t</code> or C-t</code> to switch between a vertical and horizontal
split or vice versa.</p>
Set a language at runtime</h2>
</asciinema-player>
The language for a buffer may now be set at runtime. Use
:set-language language</code> (or :lang language</code> for short) to set the language
and switch language servers.</p>
Wrapping up</h2>
These are just some highlights from the changes in 22.05. Check out the
changelog</a> for the full set. Pick up the release binaries for 22.05 on the
release page</a>. Starting with this release, an AppImage is included in the
release binaries for easier usage from Linux.</p>
Expect plenty more features and improvements in Helix 22.07 coming in July.
Contribute and follow along with development in the
GitHub repository</a> and be sure to join in on discussions in the
Matrix channel</a>.</p>


Release 22.03 Highlights
2022-03-28T16:25:00+00:00
Ranging from small quality-of-life improvements and fixes to large features
and refactors, Helix 22.03 brings some exciting changes. Helix is a modal
text editor with built-in support for multiple selections, Language
Server Protocol (LSP), tree-sitter, and now Debug Adapter Protocol (DAP).</p>
Before we look at the highlights, there are some administrative notes.
master</code> branch changes are now published separately from the release
documentation</a>. Find the new master</code> docs here</a>.
Helix is switching versioning schemes. Expect to find new releases in
Calendar Version format: YY.0M(.MICRO)</code>. We're aiming to cut regular
releases every two months or so. Check out the changelog</a>
for all of the new features and fixes from this release.</p>
With that out of the way, let's check out the highlights!</p>
Health-check</h2>
Helix 22.03 brings a new CLI flag: hx --health</code>. Use the new health-check
flag to troubleshoot missing language servers and queries.</p>
Check the health of all languages with hx --health</code> or ask for details
about a specific language with hx --health <lang></code>.</p>
</asciinema-player>
Experimental DAP Support</h2>
Debug Adapter Protocol (DAP) is an abstract protocol for editors and debuggers
to communicate. It's very similar in spirit to the Language Server Protocol
(LSP), but built for debugging. Interact with the debug adapter with
<space-d></code>.</p>
</asciinema-player>
Note that the DAP adapter is experimental: it isn't yet documented, there may
be bugs, and the UX is a bit clunky. Contributions are very welcome!</p>
Incremental Injection Parsing Rewrite</h2>
One of the cooler features of syntax highlight driven by tree-sitter is the
ability to inject</em> a language into another language's document. For example,
if you're writing Markdown, you might use a code-fence like so:</p>
This is some rust:
</span>
</span>```rust
</span>println!("Hello, world!")
</span>```
</span></code></pre>
Helix highlights the Rust block by injecting tree-sitter-rust. Injections
have been rewritten so that changes within are now parsed incrementally, which
is a big speed boost when editing documents with large injected blocks.</p>
Along with this rewrite, Helix now supports combined</em> injections. For example,
when highlighting Interactive Elixir (IEx), we might have a block of code like
the following:</p>
iex> send(self(), </span>:hello</span>)
</span>iex> </span>receive </span>do: </span>(</span>:hello </span>-> </span>:ok</span>)
</span></code></pre>
The IEx grammar injects tree-sitter-elixir into each line after the prompt
token. Combined injections cover the case where separate injected documents
must be parsed in one combined document, like so:</p>
iex> </span>if </span>true </span>do
</span>...>   </span>:ok
</span>...> </span>end
</span></code></pre>
Helix can now parse all three lines together. In the future this can be used
to add support for templating languages like EJS or ERB.</p>
Tree-Sitter Grammars Refactor</h2>
In the past, tree-sitter grammar repositories have been added to the Helix
repository as Git submodules. Submodules can be painful to work with though,
especially when there are more than 50 in a repository. Cloning, CI, and
packaging times have slowed down as language support has improved.</p>
Helix 22.03 completely overhauls the system for tree-sitter grammars. The headline
is that submodules are gone</strong>! If you're working with the source, you can
now clone with a standard git clone https://github.com/helix-editor/helix</code>.
So where did the tree-sitter submodules go? They've been replaced with two
new CLI flags: hx --grammar fetch</code> to clone grammar repositories into the
runtime directory and hx --grammar build</code> to compile them. Use -g</code> for
short. Grammar repositories are shallow-cloned in parallel, so fetching all
60 grammars can now take as little as 6 seconds on a good connection.</p>
If you're building from source or developing Helix, note that fetching and
building are included in the helix-term</code> build step, so you should not
need to manually fetch or build grammars.</p>
Additionally, if you would like to customize which tree-sitter grammars
you fetch and build, you may now add the use-grammars</code> key to the top</strong> of
your languages.toml</code>:</p>
</asciinema-player>
If you're writing a tree-sitter grammar, you can try out integrating it
by pointing helix to your grammar's local path in languages.toml</code> without
needing to publish changes to a Git remote:</p>
[[language]]
</span>name </span>= "</span>mylang</span>"
</span># ..
</span>
</span>[[grammar]]
</span>name </span>= "</span>mylang</span>"
</span>source </span>= { </span>path </span>= "</span>/local/path/to/tree-sitter-mylang</span>" }
</span></code></pre>
Running hx -g build</code> will build the grammar. Add some queries and you're
on your way to interactive grammar development.</p>
Up Next</h2>
The next release is sure to be exciting as well. Contribute and follow
along with development in the GitHub repository</a> and be sure to
join in on discussions in the Matrix channel</a>.</p>

`Wrapping up</h2> As always, this is just the highlights from the 25.01 release. Check out the full changelog</a> for the details.</p> Come chat about usage and development questions in the Matrix space</a> and follow along with Helix's development in the GitHub repository</a>.</p>`

`Wrapping up</h2>``As always, this is just the highlights from the 24.03 release. Check out the full changelog</a> for the details.</p> Come chat about usage and development questions in the Matrix space</a> and follow along with Helix's development in the GitHub repository</a>.</p>`

`Wrapping up</h2>As always, this is just the tip of the iceberg for the 23.10 release. Check out the changelog</a> for the full details.</p> Come chat about usage and development questions in the Matrix space</a> and follow along with Helix's development in the GitHub repository</a>.</p>`

Autosave when the terminal loses focus</h2>
Terminals with support for focus events can now automatically save the current file when you focus on a new window. Enable this behavior by setting the `editor.auto-save</code> configuration key to true</code>.</p>`

`Up Next</h2> The next release is sure to be exciting as well. Contribute and follow along with development in the GitHub repository</a> and be sure to join in on discussions in the Matrix channel</a>.</p>`

Helix

Release 25.07 Highlights

Release 25.01 Highlights

Release 24.03 Highlights

Release 23.10 Highlights

Release 23.03 Highlights

Release 22.12 Highlights

Release 22.08 Highlights

Release 22.05 Highlights

Release 22.03 Highlights

Helix

Release 25.07 Highlights

Release 25.01 Highlights

Wrapping up</h2> As always, this is just the highlights from the 25.01 release. Check out the full changelog</a> for the details.</p> Come chat about usage and development questions in the Matrix space</a> and follow along with Helix's development in the GitHub repository</a>.</p>

Release 24.03 Highlights

Release 23.10 Highlights

Wrapping up</h2> As always, this is just the tip of the iceberg for the 23.10 release. Check out the changelog</a> for the full details.</p> Come chat about usage and development questions in the Matrix space</a> and follow along with Helix's development in the GitHub repository</a>.</p>

Release 23.03 Highlights

Release 22.12 Highlights

Autosave when the terminal loses focus</h2> Terminals with support for focus events can now automatically save the current file when you focus on a new window. Enable this behavior by setting the editor.auto-save</code> configuration key to true</code>.</p>

Release 22.08 Highlights

Release 22.05 Highlights

Configurable gutters</h2> Gutters can now be configured in your config.toml</code> file. For example, you can remove the line-number gutter while still showing LSP diagnostics.</p>

Release 22.03 Highlights

Up Next</h2> The next release is sure to be exciting as well. Contribute and follow along with development in the GitHub repository</a> and be sure to join in on discussions in the Matrix channel</a>.</p>

`Wrapping up</h2> As always, this is just the highlights from the 25.01 release. Check out the full changelog</a> for the details.</p> Come chat about usage and development questions in the Matrix space</a> and follow along with Helix's development in the GitHub repository</a>.</p>`

`Wrapping up</h2>As always, this is just the tip of the iceberg for the 23.10 release. Check out the changelog</a> for the full details.</p> Come chat about usage and development questions in the Matrix space</a> and follow along with Helix's development in the GitHub repository</a>.</p>`

Autosave when the terminal loses focus</h2>
Terminals with support for focus events can now automatically save the current file when you focus on a new window. Enable this behavior by setting the `editor.auto-save</code> configuration key to true</code>.</p>`

`Up Next</h2> The next release is sure to be exciting as well. Contribute and follow along with development in the GitHub repository</a> and be sure to join in on discussions in the Matrix channel</a>.</p>`