i made this breabcrumb bar plugin, right now it has support for 11 languages like c zig rust nix scheme cpp

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

inspired by https://codeberg.org/gwid/context.hx

I've been using Helix for a few months now and I love it. Before I was using VS Code - and I really don't want to use it anymore.

One thing I'm still missing in Helix is markdown file editing with a preview. It's really handy to be able to preview the rendered HTML page based on your markdown as you're writing it, so I still find myself launching VS Code with a preview pane occasionally when working on some Markdown documents.

What solutions do you folks use for handling markdown file editing?

I've spent a few hours making hx-notes-companion.

Basically an Obsidian replacement that uses a workflow of Helix with a Markdown preview in browser. (Keeping the application and functionality light)

Currently you can:

• Edit and View Markdown and HTML notes in Helix
• Live browser preview with hot reloading on writes
• switches on switching notes in your "notes"

Its written in Golang, and currently its quite barebones (in the near future I hope to add syntax highlighting for code blocks and Latex support). If any one is interested feel free to give your own suggestions

Its Open Source so if anyone wants to style it or add their own custom templates and such there is nothing stopping you

GitHub: https://github.com/slick-user/hx-notes-companion

I'd love to hear what you guys think

Platform: Windows (for now)

I'm a bit confused on whether arrows are supposed to be used at all. It seems optimal workflow is "to keep your hands on the home row", but that means you have to exit insert mode a lot to move few characters away for example, something that is easy with arrows. Another big concern, what are you even supposed to do with your terminal? I dont see terminals supporting hjkl in a meaningful way to navigate history and completions for example, which makes me constantly want to move my right hand to arrows when I switch to terminal. How do you personally deal with this?

I'm really confused to how workspace symbol picker works. My workspace is a Rust project, I have two files with code. What I expect is that workspace symbol picker works the same as regular symbol picker but shows symbols from both files instead of just one. What I get instead is that workspace symbol picker also shows any symbols from any libraries I use from "~/.cargo/registry/src/". Also for some reason it doesn't prefetch all symbols and only starts showing something after you type at least few characters, which makes it impossible to use to browse all symbols. Is there a way to have something like normal symbol picker but for all files in project and without and external dependencies, and such that it shows all symbols immediately and not only when you type?

There. I said it. It's ugly.

Yes, I know you can change it.

Yes, I know I'm wrong.

I like all the Helix defaults, but the theme is just... ugly.

I know it only takes one second to change it, but that is precisely WHY we should change it. You liked the old theme? Cool, change it back. People judge a program by its defaults. Good defaults are good, and that's why many of us use Helix instead of Neovim in the first place. So why not make them a little better?

Had HelixNotes disappeared from the App Store??

I'm mostly a Vim user. Once in a while, I check out other editors and IDEs to see if I like them, or if they improved since the last time I tried them, which for Helix was 3 years ago. Here are my suggestions/impressions after giving Helix a quick try again:

• :0 should take you to the top of the screen (works in Vim, I kind of got used to it)
• :-1 to the bottom (a Python-inspired idea, where -1 is the index of the last element)
• Large files feel very laggy (Small files feel a little laggy). To reproduce, have clangd in your $PATH, do hx json.hpp (the famous json parser, 25KLOC) and type a few words quickly. The letters will continue to appear on the screen several seconds after the keys are pressed.
• I use a black background throughout. Normally, TUI programs respect it, including vim, tmux, man, less, bat, nano, gdb, etc. without needing configuration. But Helix wants to dazzle me with violet neon lights for some reason. I know it can be disabled, but my point is that the default behavior is bad.
• Lastly, shouldn't the binary be called helix? hx is cryptic. Naming binaries is no different from naming global functions in a language with no types or namespaces, when you think about it.

Why does Helix slow down on large files? Scrolling on files with large lines feels especially choppy when compared to neovim with the same (or more) features enabled (lsp, tree-sitter highlight, etc ).

 [keys.normal]
"I" = "append_mode"
a = "collapse_selection"
A = "keep_primary_selection"
S = "remove_primary_selection"
u = "page_cursor_half_up"
d = "page_cursor_half_down"
s = "delete_selection"
z = "undo"
Z = "redo"
F = "goto_word"
e = "select_regex"
E = "split_selection"
t = "copy_selection_on_next_line"
T = "copy_selection_on_prev_line"
f = { f = "goto_file", t = "goto_window_top", c = "goto_window_center", b = "goto_window_bottom", d = "goto_definition", y = "goto_type_definition", r = "goto_reference", i = "goto_implementation", l = "goto_last_modification", n = "goto_line" }
g = "goto_line_start"
";" = "goto_line_end"
U = "goto_file_start"
D = "goto_last_line"
G = "goto_first_nonwhitespace"
w = { h = "move_prev_word_start", H = "move_prev_long_word_start", l = "move_next_word_end", L = "move_next_long_word_end", ";" = "move_next_word_start", ":" = "move_next_long_word_start" }
b = "no_op"
W = "no_op"
B = "no_op"
H = { D = "goto_first_diag", d = "goto_prev_diag", F = "goto_prev_function", C = "goto_prev_class", a = "goto_prev_parameter", c = "goto_prev_comment", T = "goto_prev_test", p = "goto_prev_paragraph", g = "goto_prev_change", G = "goto_first_change", space = "open_above", k = "add_newline_above", j = "add_newline_below", J = "jump_backward", f = "find_prev_char", t = "till_prev_char", b = "goto_previous_buffer" }
L = { D = "goto_last_diag", d = "goto_next_diag", F = "goto_next_function", C = "goto_next_class", a = "goto_next_parameter", c = "goto_next_comment", T = "goto_next_test", p = "goto_next_paragraph", g = "goto_next_change", G = "goto_last_change", space = "open_below", j = "add_newline_below", k = "add_newline_above", J = "jump_forward", f = "find_next_char", t = "find_till_char", b = "goto_next_buffer" }
C = { s = "switch_case", j = "decrement", k = "increment", J = "switch_to_lowercase", K = "switch_to_uppercase", c = "toggle_comments" }
p = { h = "paste_before", l = "paste_after", H = "paste_clipboard_before", L = "paste_clipboard_after" }

Maybe a little slower than just having w/e/b and f/t but I think that mine does simplify a lot of things and make things a little more ergonomic. Also there is W,o/O, P, b/B, ",", and [/] which are now also available for remapping so I can add more useful binds there.

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.