Obsilix

The parts of Helix you actually use — modal editing, selection-first motions, and multiple cursors — inside Obsidian.

What it is

Obsilix is an Obsidian plugin that brings Helix-style modal editing to the note editor. It's built directly on Obsidian's CodeMirror 6 core, whose native multi-range selections map cleanly onto Helix's model.

The defining trait is selection-first editing: you move or select first, then a verb acts on the selection — the opposite order from Vim. Pressing w selects the next word; d then deletes it. Every motion produces a visible selection, and every verb works across all of your cursors at once.

Install

Obsilix isn't in the community plugin browser yet. To install it manually:

git clone https://github.com/nkantar/Obsilix
cd Obsilix
npm install --legacy-peer-deps
npm run build

Copy main.js, manifest.json, and styles.css into your vault at .obsidian/plugins/obsilix/, then enable Obsilix under Settings → Community plugins.

Obsilix owns modal editing, so turn Obsidian's built-in Vim mode off (Settings → Editor). It will warn you on load if Vim mode is still enabled.

To switch modal editing off without disabling the plugin, run Obsilix: Toggle modal editing from the command palette — bind it to a hotkey under Settings → Hotkeys if you flip it often — or use the switch in Settings → Obsilix. While off, Obsilix contributes nothing at all: no keymap, no modes, and the status bar reads OFF.

That switch starts on on desktop and off on mobile. Neither Obsidian nor the web platform can detect an attached hardware keyboard, and on a touchscreen alone notes open in Normal mode with no way to reach Insert — effectively read-only. Pair a keyboard with your phone or tablet and turn it on. The platform only picks the starting value; once you toggle it, your choice is what sticks.

Modes

Notes open in Normal mode. Esc returns to Normal from anywhere.

Mode	Behavior
Normal	Default, and how notes open. Motions create/replace a selection; verbs act on it. The caret shows as a block.
Select	Entered with `v`. Motions extend the current selection instead of replacing it. The caret shows as an underline.
Insert	Ordinary typing, entered with `i`/`a`/`o` (and capitals). `Esc` leaves. The caret is Obsidian's usual thin bar.

The status bar in the bottom right names the current mode too, so you have both a cue at the cursor and one in a fixed place.

Keymap

Everything Obsilix supports today. Motions build a selection; verbs act on it. Documents version 0.1.0 — bindings can change between releases.

Motions & selection

n before a key	Count prefix — repeat the command n times (`3w`, `5j`, `2d`). Counts on `c`, `y`, `r`, `~` and the insert keys are ignored.
n`gg`	Go to line n.
`h` `j` `k` `l`	Move one character left · right and one visual line down · up, so a soft-wrapped line is walked one screen row at a time. Collapses to a plain cursor; `h`/`l` stay within the line.
`w` `e` `b`	Next word start · next word end · previous word start. Word boundaries follow Helix character categories (whitespace / word / punctuation).
`W` `E` `B`	The same three motions over long words — runs delimited by whitespace only, so `foo.bar` is one word.
`f`c `t`c	Select forward to c (`f`) or up to just before it (`t`), within the line.
`F`c `T`c	Same, searching backward.
`Alt`+`.`	Repeat the last `f`/`t`/`F`/`T`, without retyping the character.
`x`	Extend the selection to whole line(s). Repeat to grow downward.
`X`	Extend the selection to whole line bounds, without reaching for the next line.
`gg` · `ge`	Go to document start · document end.
`gh` · `gl`	Go to line start · line end.
`gs`	Go to the first non-whitespace character of the line.
`gj` · `gk`	Move one actual line down · up, skipping over the wrapped rows that plain `j`/`k` stop on. Takes a count.
`gt` · `gc` · `gb`	Move the cursor to the top, middle or bottom line of the viewport — the mirror of `zt`/`zz`/`zb`, which move the view instead.
`gf`	Follow the link under the cursor. Helix's goto-file, pointed at Obsidian's idea of a file reference: `[[wikilinks]]` and `[label](target)` both work, aliases and `#heading` anchors included.
`[p` · `]p`	Go to the previous · next paragraph. Paragraphs are separated by blank lines.
`mm`	Jump to the matching bracket.
`mi`o · `ma`o	Select inside · around the text object o: a bracket (`(` `[` `{` `<`, either delimiter, or `b`/`B`), a quote (`"` `'` `), `w`/`W` for a word, or `p` for a paragraph.
`%`	Select the whole document.
`_`	Trim leading and trailing whitespace off each selection.

Search

`/`text `Enter`	Search; the selection jumps to the first match. Accepts a regular expression.
`?`text `Enter`	The same, searching backward from the cursor.
`n` · `N`	Jump to the next · previous match.
`*`	Use the current selection as the search pattern. Like Helix, this only sets the pattern — press `n` to move.
`Alt`+`*`	The same, wrapped in word boundaries, so searching for `id` skips `width`.
`Ctrl`+`O` · `Ctrl`+`I`	Jump back · forward through the jumplist. Searches and whole-file gotos push an entry.
`Ctrl`+`S`	Push the current position onto the jumplist by hand, so you can wander off and `Ctrl`+`O` back. Note this takes over Obsidian's save shortcut in Normal and Select mode — harmless, since Obsidian saves on its own.

Multiple cursors

`s`regex `Enter`	Select every regex match inside the current selection — one cursor per match.
`S`regex `Enter`	Split the selection on the regex — one cursor per piece between matches.
`Alt`+`s`	Split the selection on newlines — one cursor per line. The common case of `S`, without the prompt.
`&`	Insert spaces so every selection starts at the same column. Aligns the start column only, not every column on the line.
`Alt`+`(` · `Alt`+`)`	Rotate the contents between selections, backward · forward. The selections stay put; the text inside them moves.
`Alt`+`n`	Add a cursor at the next occurrence of the primary selection (wraps around). Helix has no native binding for this; `Alt`+`.` is its repeat-last-motion and `Ctrl`+`D` is the half-page scroll.
`C` · `Alt`+`C`	Copy the primary cursor to the line below · above, keeping its column. Lines too short to hold the column are skipped.
`;`	Collapse each selection to a single cursor (deselect).
`,`	Collapse back to just the primary cursor.
`Alt`+`,`	The complement: drop the primary cursor and keep all the others.
`(` · `)`	Rotate which cursor is primary, backward · forward.
`K`regex `Enter`	Keep only the selections that match the regex.
`Alt`+`K`regex `Enter`	Drop the selections that match the regex.
`Alt`+`;`	Flip anchor and head, so the next motion grows the other end of the selection.
`Alt`+`:`	Point every selection forward (anchor first, head last).

Editing verbs

`d`	Delete the selection, yanking it first (an empty selection deletes the character under the cursor).
`c`	Change — yank and delete the selection, then enter Insert mode.
`Alt`+`d` · `Alt`+`c`	Delete · change without yanking, leaving the clipboard untouched.
`y`	Yank the selection to the system clipboard.
`p` · `P`	Paste from the system clipboard after · before the selection.
`R`	Replace the selection with the clipboard contents.
`r`c	Replace every selected character with c.
`~`	Switch the case of the selection.
` · `Alt`+`	Force the selection to lower · upper case, rather than toggling each character.
`Ctrl`+`A` · `Ctrl`+`X`	Increment · decrement the selected number. As in Helix it bumps the selection itself, so the selected text has to be an integer and nothing outside it is touched — with no selection that's the single character under the cursor. Takes a count as the amount, so `5Ctrl`+`A` adds five. Zero padding survives: `007` becomes `008`.
`J`	Join the lines the selection spans, separated by a single space.
`>` · `<`	Indent · unindent the selected lines, using the editor's own indent unit.
`u` · `U`	Undo · redo.

Surround, registers & macros

`ms`c	Surround each selection with c. Brackets and quotes pair up automatically; any other character is used on both sides.
`md`	Delete the innermost pair surrounding the cursor.
`mr`c	Replace that pair with c. Unlike Helix this takes only the replacement and always targets the innermost pair.
`"`c	Send the next yank, delete or paste to register c instead of the system clipboard. Registers last for the session.
`q`	Start recording a macro; press `q` again to stop. The status bar shows REC while recording.
`Q`	Replay the recorded macro. Takes a count, so `10Q` runs it ten times.

Entering Insert mode

`i` · `a`	Insert before · append after the selection. With nothing selected, `a` puts you after the character under the cursor. Both keep the selection through Insert the way Helix does — it parks the anchor and moves only the cursor — so on `Esc` `a` leaves the character under the cursor and everything you typed selected, while `i` hands back what was selected before, with the typed text outside it.
`I` · `A`	Insert at the line's first non-blank character · append at line end. These collapse to a plain cursor, as they do in Helix.
`o` · `O`	Open a new line below · above and start typing.
`.`	Repeat the text typed during the last Insert session, at every cursor. Replays the text, not the entry key — `o` then `.` does not open another line.
`Ctrl`+`W` · `Ctrl`+`U`	In Insert mode: delete the word before the cursor · delete back to the line start.

Modes & scrolling

`v`	Toggle Select mode (motions extend the selection).
`Esc`	Return to Normal mode from Insert or Select.
`Ctrl`+`D` · `Ctrl`+`U`	Scroll a half page down · up.
`Ctrl`+`F` · `Ctrl`+`B`	Scroll a full page down · up.
`Ctrl`+`E` · `Ctrl`+`Y`	Scroll one line down · up, leaving the cursor where it is. Takes a count.
`zz` · `zt` · `zb`	Scroll so the cursor's line sits in the middle · at the top · at the bottom of the view. The cursor itself does not move.
`Ctrl`+`C`	Toggle comments, as in Helix. Markdown declares no line-comment token, so this wraps the selected lines in Obsidian's `%%…%%`; fenced code blocks use their own language's comment syntax. Note this shadows the OS copy shortcut on Windows and Linux while in Normal or Select mode — `y` is the yank.

Not included yet

Deliberately out of scope for now: ex-style commands such as :w and :q — Obsidian's own command palette covers that ground — and tree-sitter text objects, meaning functions, classes and the like. mi/ma handle brackets, quotes, words and paragraphs by scanning the text instead. There is also no coexistence with Obsidian's built-in Vim mode.