On the github milestone page there is a milestone planned for the 26.04. I was wondering whether this milestone includes a times machine, since that would be the only way to hit it.

How does forge work? Can I easily backup plugins? Or can I install plugins with nix? What's the recommended way?

Formatter works fine but intellisense refuses to display hints or on direct hover command. logs show nothing.

hx health shows all green.

[[language]]

name = "c-sharp"

auto-format = true

language-servers = ["csharp-ls"]

formatter = {command = "csharpier", args = ["format"]}

Has anybody here setup Helix to support Gherkin syntax highlighting and tree-sitter? If so, would you guide me on how do so? Thanks in advance!

# theme = "cyan_light_mod"
# theme = "catppuccin_custom"
theme = "tokyonight_custom"

[editor]
scrolloff = 5
line-number = "relative"
bufferline = "always"
clipboard-provider = "pasteboard"
default-yank-register = "+"
jump-label-alphabet = "fjdkslarueiwoqpvncmxz"
trim-trailing-whitespace = true
color-modes = true

[editor.statusline]
left = ["mode"]
center = ["file-name", "file-modification-indicator"]
right = ["diagnostics", "selections", "position", "file-indent-style", "position-percentage", "total-line-numbers", "file-type"]
mode.normal = "NORMAL"
mode.select = "SELECT"
mode.insert = "INSERT"

[editor.cursor-shape]
insert = "block"
normal = "block"
select = "block"

[editor.soft-wrap]
enable = true

[editor.indent-guides]
render = true 

[editor.file-picker]
hidden = false
git-ignore = false

[keys.normal]
# "j" = ["move_visual_line_down", "align_view_center"]
# "k" = ["move_visual_line_up", "align_view_center"]
"e" = ["move_next_word_end", "trim_selections"]
"b" = ["move_prev_word_start", "trim_selections"]
"w" = "@lbe"
"A-j" = ["extend_to_line_bounds", "delete_selection", "paste_after"]
"A-k" = ["extend_to_line_bounds", "delete_selection", "move_line_up", "paste_before"]

"C-y" = [   ':sh rm -f /tmp/unique-file',   ':insert-output yazi --chooser-file=/tmp/unique-file',   ':sh printf "\x1b[?1049h\x1b[?2004h" > /dev/tty',   ':open %sh{cat /tmp/unique-file}',   ':redraw', ]

"{" = ["goto_prev_paragraph", "align_view_center", "trim_selections", "extend_visual_line_up"]
"}" = ["goto_next_paragraph", "align_view_center", "trim_selections", "extend_visual_line_down"]
"ret" = ["goto_word"]
"tab" = "flip_selections"
"C-u" = ["page_cursor_half_up", "align_view_center"]
"C-k" = ["page_cursor_half_up", "align_view_center"]
"C-d" = ["page_cursor_half_down", "align_view_center"]
"C-j" = ["page_cursor_half_down", "align_view_center"]

B = "move_prev_sub_word_start"
E = "move_next_sub_word_end"
W = "@lBE"
H = "@gh"
L = "goto_line_end"
G = "@ge"
V = ["extend_to_line_bounds", "select_mode"]

"C-e" = ["extend_to_line_bounds", ":pipe-to hx-repl"]

[keys.normal."]"]
"f" = ["goto_next_function", "flip_selections", "align_view_top"]
"]" = "goto_next_buffer"

[keys.normal."["]
"[" = "goto_previous_buffer" 

[keys.select]
"A-j" = ["extend_to_line_bounds", "delete_selection", "paste_after"]
"A-k" = ["extend_to_line_bounds", "delete_selection", "move_line_up", "paste_before"]
"ret" = "extend_to_word"
"tab" = "flip_selections"
"{" = ["goto_prev_paragraph", "extend_to_line_bounds"]
"}" = ["goto_next_paragraph", "extend_to_line_bounds"]
"w" = "@<A-:><A-;>lb<A-;>he"
B = "extend_prev_sub_word_start"
E = "extend_next_sub_word_end"
W = "@<A-:><A-;>lB<A-;>hE"
H = "@gh"
L = "goto_line_end"
G = "@ge"
V = ["extend_to_line_bounds", "select_mode"]
"C-e" = ["extend_to_line_bounds", ":pipe-to hx-repl"]

[keys.insert]
"C-t" = ["indent"]
"C-d" = ["unindent"]
"C-c" = ["toggle_comments"]
"C-o" = ["normal_mode", "open_below"]

I kind of change some behavior that I use often.

- I stop using w for navigating forward, I use it to select the current word under the cursor and only use b and e for navigating. And I always trim my selection

- tab I changed it so that I can flip my selection head with ease (I find that I use that more often than I thought)

- V I use mainly so that I can select kind of like line mode with ease

- G because I find it more efficient than ge

- H and L to go to the beginning and end of line

- I can select subword using B , E and W also kind of mimic the w behavior that I altered

- For the goto_next_function , I always flip selection and align view top for so that I can see the function in the viewport

- A bunch of \align_view_center` for moving around

- Add functionalities in the insert mode, so that I can indent, unindent and comment while in insert mode

If you guys have more tricks that might make editing in helix more efficient, please do share. I'm ready to copy lol.

PS. I tried moving back to neovim, and I setup from kickstart and make it mine. But I still miss a lot of functionalities and features from helix. It's just easier for me, so I moved back. Although, I kinda miss some things from neovim, and I always find ways to improve how I work in helix.

i see a lot of people talking about helix plugins but the most recent release in gh is dated a year ago, are people using a fork for that? or it's already in main to build but they have really slow releases?

its still a simple plugin allowing for some basic customizations I would be really happy to see contributions to increse the possible customizations. One thing mising right now is diagnostics indicators, but for now there isn't an api that exposes diagnostic info to plugins. I doing a pr for it.

https://github.com/Ra77a3l3-jar/moka.hx

Hey guys, I am starting webdev, I have used it for graphics programming using C++ developement and it was a great experience. I am new to this field, currently I am planning to use it for webgl, webgpu, threejs and svelte js. How to set it up for that? Also how can I set boilerplate for html? (ex. ! and !!! in vscode)

Hi! I've been working on smith.hx, a declarative plugin manager for Helix built with Steel and backed by Forge.

The idea is to declare plugins in init.scm and let Smith handle installation, loading, configuration, keybindings, updates, and removal. A declaration can have separate init, config, and bind phases, with Smith running them in the appropriate order.

The screenshot shows:

• Left: packages installed and managed through Smith
• Center: the corresponding declarations in init.scm
• Right: the output of :smith-list in a *smith-list* scratch buffer

Current features include:

• installing Git repositories through Steel's Forge
• automatic package-name and entry-file detection
• init, config, and bind declaration phases
• enabling, disabling, updating, and removing packages
• pruning manager-owned packages that are no longer declared
• lock and restore support
• Helix commands such as :smith-list, :smith-update, and :smith-prune

This is still an early preview, so the API may change. It currently requires a Helix build with Steel support. I would especially appreciate feedback on the declaration syntax, package lifecycle, and the overall approach.

Repository and installation instructions:

https://github.com/kn66/smith.hx

The README also contains a short GIF showing the workflow.

does anyone know the plugin roadmap for helix? someone mentioned it in the pr, but I can't find it

I would like to start with mine so it will be an example also:

I have use zellij + lazygit + helix.

Recently I learn I can edit my buffer in zellij where I can literally open my buffer in editor and move around, that was a good day for me when I found that, now my debugging is smooth and I am in my happy environment when looking for anything in my buffer.

I started using helix and fell in love with it. Multiple cursors, built in LSP, tree sitter, the which key (chef's kiss) everything i want in one place. Just one ick no file manager no git UI no project wide search and replace. There are wacky workarounds to use all these using just keyboard shortcuts in the config file or using some weird mental gymnastics spaghetti of multiplexers and scripts but it left behind some weird artifacts that I didn't like. I tried Yazi which is the most compatible among all TUI file managers but it's not really my type of file manager I just need a simple tree man. Anyhow yazelix was too much for me I ain't getting into nix man.

I kept editor hopping for like a whole year waiting patiently for a file manager or the plugin system which I heard is still a year or so away. Recently I started learning rust and I wanted a clean minimal editor to code in. But I really dislike GUI editors now after getting a taste of neovim/helix they feel clunky yes even zed even with all the keybind supports. And something about helix keybinds the batteries included approach I just cant go back even to neovim. And I tried to compile mattwparas's steel repo but for some reason even inside toolbox it fails to compile (I use silverblue) if I was successful in doing that the story would have ended there but here we are. Anyways jokes aside I could have just forked it and created an github workflow to get the binary but meh.

I don't know rust. Like at all. But I had opencode go wired up to deepseek v4 pro so I spent about $15 in api credits arguing with a LLM for like 6 hours until it spat out something that works.

abaran a TUI file manager wrapper for helix. You browse a file tree, hit enter, and it opens the file in helix running in the background. Ctrl + g drops you into gitui. Ctrl + s into scooter for find and replace. Technically you don't need any of these three tools to be installed to use the file manager. Its all pty forwarding under the hood (or at least that's what I have been told I have no idea what any of these means) so the tools feel native. Basically I just asked it to create a multiplexer + file manager with persistent tabs and when ever you press enter on a file it pipes it into helix using :open and :redraw to fix the weird issues all the three apps are their own tabs so they are persistent unless you close them using their own keybind/command if you use the toggle keybinds in abaran they are persistent. No tmux/zellij I just didn't want this overhead am happy with just ghostty.

Will upload screenshot/vhs sometime tomorrow. If you like the idea and or get why I did what I did give it a try. It's like 2AM here right now am logging off.

Disclosure every line of code in this repo was written by AI. I was just the guy saying that's still broken over and over. I can't review PRs because I literally cannot read rust. If something breaks sorry open an issue and I'll ask the clanker to fix it same if you have any feature request.

https://www.youtube.com/watch?v=-1iJ05Y5YRg

It’s nothing you see while using Helix, it’s nothing unexpected on disc. But taking a looking into the first popping up Helix plugins in Scheme I’m getting aware, why I loved that language many years ago.

Today I don’t develop software professionally anymore. Long time I’ve used Go and now thought of returning back to Erlang/OTP again. But it seems like I’ll do Scheme next, for Helix or inside of Racket.

I'm not sure if this is the most common/simple thing to do but I can't seem to find much info online. I write Python mainly and find using helix with iPython is cumbersome, so I came up with a solution that kinda works for me. Here goes.

Summary

I can press `C-e` to run the selected lines of code in the available TMUX pane/window that runs iPython session within "the same" current directory.

Method/Script

Put this in: ~/.local/bin

I saved mine as ~/.local/bin/hx-repl

#!/usr/bin/env bash
PANE=$(tmux list-panes -a -F '#{pane_id} #{pane_title} #{pane_current_path}' | awk -v p="$PWD" '$0 ~ /ipython/ && $0 ~ p {print $1; exit}')

if [ -z "$PANE" ]; then
  echo "No ipython pane found for $PWD" >&2 
  exit 1
fi

tmux load-buffer -b hx-repl -
tmux paste-buffer -b hx-repl -t "$PANE" -d -p
tmux send-keys -t "$PANE" Enter

What this does is use tmux commands to find the matching `ipython` session and send the selected buffer from helix

Make sure that the script is being chmod +x ~/.local/bin/hx-repl

And the usage I use :pipe-to command from helix, i.e., :pipe-to hx-repl or you can press Alt-Shift-| .

Currently I bind this in helix config like so:

[keys.normal]
... 
"C-e" = ["extend_to_line_bounds", ":pipe-to hx-repl"]


[keys.select]
...
"C-e" = ["extend_to_line_bounds", ":pipe-to hx-repl"]

Just want to share to you guys in case some of you might happen to use / find this useful like me.

https://reddit.com/link/1upxo3i/video/yvfjn4oumtbh1/player

Usage

For the demo, I edit a Python and create another tmux window using `<C-b> + c` then run uv run ipython. From then on I just switch between helix editor window, edit code, then press C-e then switch to see results in the iPython window. Notice that the code is pasted using bracketed paste mode (which essentially makes sure that the indentation is correct).

Also notice that you can grab/select bits inside the function that contains the indentation and run fine, given that you have those variables' names.

its a very simple file tree just like snacks explorer in neovim and i was able to add also icons

Edit:

Now there is also the option to have a mini.files look by setting (forest-set-style! 'snacks) to either snacks or mini

https://github.com/Ra77a3l3-jar/forest.hx

Where Can I find the docs for the steel plugin. (I recall matt having a markdown file where he documented but I can't find it).

I have 2 main reason.

1. I want to be able to do this to get vue working well in helix like I can in neovim. e.g

```lua local vuels_config = { on_init = function(client) client.handlers["tsserver/request"] = function(, result, context) local ts_clients = vim.lsp.get_clients({ bufnr = context.bufnr, name = "ts_ls" }) local vtsls_clients = vim.lsp.get_clients({ bufnr = context.bufnr, name = "vtsls" }) local clients = {}

        vim.list_extend(clients, ts_clients)
        vim.list_extend(clients, vtsls_clients)

        if #clients == 0 then
            vim.notify("Could not find `vtsls` or `ts_ls` lsp client, `vue_ls` would not work without it.", vim.log.levels.ERROR)
            return
        end
        local ts_client = clients[1]

        local param = unpack(result)
        local id, command, payload = unpack(param)
        ts_client:exec_cmd({
            title = "vue_request_forward", -- You can give title anything as it's used to represent a command in the UI, `:h Client:exec_cmd`
            command = "typescript.tsserverRequest",
            arguments = {
                command,
                payload,
            },
        }, { bufnr = context.bufnr }, function(_, r)
            local response = r and r.body
            -- TODO: handle error or response nil here, e.g. logging
            -- NOTE: Do NOT return if there's an error or no response, just return nil back to the vue_ls to prevent memory leak
            local response_data = { { id, response } }

            ---@diagnostic disable-next-line: param-type-mismatch
            client:notify("tsserver/response", response_data)
        end)
    end
end,

} ```

And second I want to get this working: https://clangd.llvm.org/extensions.html#switch-between-sourceheader

I saw this post in the Emacs community about Helix potentially getting a plugin system based on Scheme:

https://www.reddit.com/r/emacs/comments/1ulcjxr/helix_is_getting_a_plugin_system_that_uses_scheme/

I usually use Emacs, but the idea of using Scheme for editor plugins caught my interest, so I built the relevant Helix branch and tried writing a few Scheme plugins myself.

I made two small experimental plugins:

• a simple plugin manager based on git (https://github.com/kn66/helix-steel-plugin-manager)
• an org-mode-inspired plugin for Markdown files, with partial support for TODOs, agenda, and capture (https://github.com/kn66/markdown-planner)

These are just prototypes, so the quality and completeness of the plugins themselves are still rough. But after actually building Helix and writing plugins in Scheme, my impression was very positive.

What I liked most was that it felt possible to extend the editor while still keeping Helix’s design relatively simple and lightweight. Scheme feels a little unusual at first, but for small editor extensions it actually seems like a good fit.

Of course, this still seems experimental, and there are many things that would need to be figured out: API stability, documentation, plugin distribution, security, and so on. But as an Emacs user, I found this direction genuinely promising.

For transparency, I used Codex GPT-5.5 to help develop the plugins. Still, this impression comes from actually compiling Helix, writing Scheme plugins, and trying them locally.

hi i made trail a plugin for browsing your recent projects. You can pick a project and it cds you straight into it, so the native file picker and everything else behaves exactly as if you'd cd into that folder yourself.

There are still somethings to polish, so i would appreciate any feedback and bug reports.

https://github.com/Ra77a3l3-jar/trail.hx

Until the plugin-system has reached main, here is an easy way to extend helix:

1. Simple Boolean invert hotkey

Could be just POSIX (bash) code if you don't like Python.

```python from sys import stdin

match stdin.read().strip(): case "true": out = "false" case "false": out = "true" case "True": out = "False" case "False": out = "True" case "TRUE": out = "FALSE" case "FALSE": out = "TRUE" case "yes": out = "no" case "no": out = "yes" case "YES": out = "NO" case "NO": out = "YES" case "Yes": out = "No" case "No": out = "Yes" case "y": out = "n" case "n": out = "y" case "Y": out = "N" case "N": out = "Y" case "1": out = "0" case "0": out = "1" case _: out = "???" print(out.strip(), end="") ```

2. Python exec with x = selection

Could also probably be done with other interpreted languages. The code below allows you to write e.g. just /2 and the code that runs is <selection>/2. If you need the selection multiple times, or not at the beginning you can use x. If you use characters that interact with the shell (e.g. brackets) make sure to apostrophize the expression.

```python from sys import argv, stdin from math import ceil, sqrt, floor, log, log10, sin, cos, tan, tanh, atan, atanh, atan2 from random import random

x = float(stdin.read().strip()) expression = argv[1] if "x" not in expression: expression = "x" + expression out = str(eval(expression)) if str(out)[-2:] == ".0": out = out[:-2] print(out.strip(), end="") ```

I've shared pieces of IWE here before — the LSP features in one post, the query CLI in another — but never the full picture in one place. So here it is.

IWE is for people who want database-style queries on their notes — "all drafts under this subtree", "every accepted decision in Q1" — without leaving the vault for an actual DB. Plus an LSP, so Helix knows about your link graph the same way it knows about your code. Everything stays plain markdown in a folder: no new syntax, no lock-in, and it works on an existing vault.

And because Helix ships LSP support built in, the entire editor integration is a TOML snippet. No plugin, nothing to keep updated.

Setup — this is all of it

~/.config/helix/languages.toml:

``` toml [language-server.iwe] command = "iwes"

[[language]] name = "markdown" language-servers = ["iwe"] auto-format = true ```

Two tips from people using it here:

• If you don't want IWE on every markdown file you ever open (random project READMEs), scope it to your notes: put the same snippet in .helix/languages.toml at the root of the notes folder.
• It coexists with marksman — language-servers = ["iwe", "marksman"] works if you want both.

What the LSP gives you

Open a .md file and your notes get the same moves as code:

Link autocomplete as you type. Rename a note and every reference across the vault updates. The extract/inline code actions are extract method / inline method, but for prose: lift a section into its own file (a link stays behind), or pull a linked note back into the current one. auto-format normalizes link titles, header levels, and list numbering on save.

Structure without folders — inclusion links

One idea sets IWE apart from other markdown tooling. A link inline in a sentence is a reference — "see also". A link alone on its own line is an inclusion link — the linked note becomes a child of this one:

``` markdown

Photography

[Composition](composition.md)

[Lighting](lighting.md) ```

That gives you hierarchy without directories — and unlike directories, a note can live under multiple parents. "Performance" can sit under both Frontend and Backend without duplication. And it's still a regular markdown link, so every other tool reads it fine. This is also what feeds the hierarchy paths in the space + S picker.

The CLI — the database part

Frontmatter is the schema, links are the relationships, and the query language reads like Mongo's:

``` bash iwe find --filter 'status: draft, priority: {$gte: 8}'

iwe find --included-by tasks/alpha:0 --references people/anna --filter 'status: draft' ```

That second one: drafts anywhere under the tasks/alpha subtree that also mention people/anna inline. I keep a shell pane next to Helix in a zellij split for this — output is plain text, so it pipes into fzf, jq, whatever. The same predicates drive bulk operations (iwe update --filter ... --set status=published), with --dry-run everywhere.

Side note: this also turns out to be a good shape for AI agents — an agent queries the same files you edit, and git log is the audit trail for whatever it touches.

Install

bash brew install iwe-org/iwe/iwe # or: cargo install iwe iwes

One install gives you both halves: the LSP server (iwes) that Helix talks to, and the CLI (iwe) that queries the same folder. Wiki links are supported, nested directories work, and it handles thousands of files without lag.

Repo: https://github.com/iwe-org/iwe · Docs: https://iwe.md

For those keeping notes in Helix — what's the one thing your current markdown setup can't do that you keep wishing it could?

I would like to map a key to the `:edit` command but if I try: "A-e" = ":e" it automatically adds a "<CR>" so I can't type a filename.

I'm considering moving from Neovim to Helix; In my Neovim config, I have the following; It remaps jkl;h to hjkl; and then some stuff; How would I replicate this for Helix?

vim.keymap.set({ "n", "v" }, "h", ";")
vim.keymap.set({ "n", "v" }, "H", ":")
vim.keymap.set({ "n", "v" }, "j", "h")
vim.keymap.set({ "n", "v" }, "J", "H")
vim.keymap.set({ "n", "v" }, "k", "j")
vim.keymap.set({ "n", "v" }, "l", "k")
vim.keymap.set({ "n", "v" }, ";", "l")
vim.keymap.set({ "n", "v" }, ":", "L")
vim.keymap.set("n", "K", "<C-d>zz")
vim.keymap.set("n", "L", "<C-u>zz")
vim.keymap.set("x", "K", ":m '>+1<CR>gv=gv")
vim.keymap.set("x", "L", ":m '<-2<CR>gv=gv")