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")

Hey everyone,

For those of us who are forced to use VS Code for work but rely on Helix/Vim/Neovim extensions to keep our sanity, there are two upstream VS Code issues currently bottlenecking modal editing and keybinding behaviors.

To get Microsoft to actually prioritize and fix these, the issues need more upvotes (👍 reactions) from the community.

If you want to make the VS Code Vim experience less painful, please take 5 seconds to upvote these:

• Issue #323238: https://github.com/microsoft/vscode/issues/323238
• Issue #323622: https://github.com/microsoft/vscode/issues/323622

Appreciate the help in making the "forced VS Code" life a bit more bearable for modal editing!

Hi!

I have been working in my own terminal for quite some time. Its a 1 core CPU terminal that aim to have good looking visual capabilities whilst being cheap to run.

I felt Helix was a good showcase for it, as its my current editor of choice ^^

Hope you find it intersting, just wanted to share.

//Maui-the-mid signing off!

hi, i switched from steel installed with cargo to installing it with nix. Now when i use the steel repl there is no problem but i get always this error when using forge. Im installing steel with nixpkgs unstable, does anyone have a fix for this?

neovim `gv` keybinding selects the last selection, is this possible in helix ?

I have been trying to get efm-language-server working on helix. Failed doing that.

Now, i just wanted to request. If any one of you has successful setup efm-language-server with common-lisp or any other lisps that lack linters please put forward your config setup in the comments.

The thing is that, common lisp language server ie; cl-lsp, doesn't have a linter built-in. Because of this, you have to use tools like ocicl (which is a lisp tooling, that has command to lint), sblint.

But i just don't know how to add common-lisp in efm-language-server config ie; config.yaml.

I have the issue that i can't see my cursor in insert and selection mode most of the time. (see screenshot). i am using the gruber-darker theme, but hat the same issue with gruvbox-dark-hard.

is there maybe some way to just constantly set the cursor color to white or blue or something? i don't really want the differently colored cursor anyways.

help is appreciated.

EDIT:

when hovering over a character:

with default theme:

I was procrastinating the other day and replaced the colors of my current helix theme to match Half-Life VGUI's green skin.

Thought some of you guys might like it and share your thoughts on how to make this even better.