A modal text editor for the terminal. Built in Zig, with tree-sitter syntax highlighting and built-in LSP integration for 20+ languages.

Stem aims to keep modal editing approachable: Vim-style modes, a Space leader, and a discoverable command palette. ZLS is embedded so Zig works with no setup; other language servers install on request via stem lsp install.

Prebuilt binaries and one-line install scripts will land with the first tagged release. For now, build from source — zig build does everything end-to-end.

Requires Zig 0.16+ and a C compiler. All other dependencies (tree-sitter, language grammars, ZLS) are fetched by zig build.

git clone https://github.com/ooyeku/stem.git
cd stem
zig build run

To build and install:

macOS / Linux (bash, zsh, sh):

./install.sh                  # build ReleaseFast, install, refresh plugins
./install.sh --prefix ~/.local

Windows (PowerShell 5.1+, no admin needed):

.\install.ps1                          # install into %LOCALAPPDATA%\Programs\stem
.\install.ps1 -Prefix C:\tools\stem    # custom prefix
.\install.ps1 -NoPath                  # skip the user-PATH update

If PowerShell blocks the script with an execution-policy error, launch it as powershell -ExecutionPolicy Bypass -File .\install.ps1.

Both installers compile from source (zig build -Doptimize=ReleaseFast), copy the binary, install bundled wasm plugins to the system prefix and refresh the per-user plugin dir at ~/.stem/plugins/ (%USERPROFILE%\.stem\plugins\ on Windows), and add the bin dir to PATH when it isn't already there.

./uninstall.sh             # remove the binary and bundled plugins
./uninstall.sh --purge     # also remove ~/.stem (config, logs, LSP cache)

.\uninstall.ps1            # remove binary, plugins, and PATH entry
.\uninstall.ps1 -Purge     # also remove %APPDATA%\stem + %LOCALAPPDATA%\stem

• Modal editing — Select, Insert, Visual, View, and Terminal modes
• Multi-buffer workflow with a tab bar
• Horizontal and vertical split panes
• Transactional undo/redo with cursor restoration
• Multi-cursor editing (Sublime-style Ctrl+D add-next-occurrence)
• Vim-style text objects (w W p " ( [ { …) for select inside / around
• Surround commands: wrap selection, change or delete a pair
• Named bookmarks (m<a-z> set, '<a-z> jump) persisted per project
• Incremental in-buffer search with / and ?, smart-case, live match count
• Project-wide search (Space /) with per-match replace confirmation
• Fuzzy file picker, buffer picker, and command palette
• Tree-sitter syntax highlighting for 29 languages
• LSP integration for 23 external language servers plus embedded ZLS for Zig (with optional format-on-save)
• LSP code actions (Space C), range format (Space F), signature help (auto-popup in Insert mode), and inlay hints (opt-in)
• Inline diagnostics ("error lens") rendered at end-of-line
• Word-under-cursor highlight after a short idle
• Integrated terminal mode
• Manifest-driven plugin system with wasm and exec runtimes
• Auto-completion, hover docs, go-to-definition, references, diagnostics, and document symbols (via LSP)
• Jump to next/previous diagnostic (]d/[d), git hunk (]g/[g), AST sibling (]s/[s), function (]m/[m)
• Session restore with crash-recovery snapshots
• Periodic auto-save backups of dirty buffers in ~/.stem/recover/, surfaced at startup if any survived a crash
• Large-file mode: files past 5 MB / 50k lines auto-degrade — tree-sitter, brackets, LSP, and auto-pair disabled so a multi-MB log stays responsive. [LARGE] badge in the status bar
• Background workspace file index for instant Find queries
• CLI search tools (stem --find, --vfind, --scope)

Syntax highlighting works for: Zig, Python, JavaScript, TypeScript, TSX, JSON, Bash, Go, HTML, CSS, Rust, C, C++, Java, Ruby, C#, PHP, Swift, Kotlin, Lua, Dart, Elixir, Haskell, OCaml, Scala, R, Perl, Erlang, Markdown.

Language servers installable via stem lsp install <name>:

stem lsp install all walks the list and installs every server whose prerequisites are available.

stem                       # empty buffer
stem myfile.zig            # open a file
stem file1.zig file2.zig   # open multiple files
stem ./src                 # open a directory

# CLI search tools
stem --find "pattern"      # grep-like text search
stem --vfind "pattern"     # interactive visual search
stem --scope file.zig fn   # search within a specific file

stem --help                # all options
stem --version             # version info

Stem leans on a Space leader and a discoverable command palette (Space f) for most actions. The bindings below cover everyday editing; everything else is reachable through the palette.

Press Space ; (or Space ?) at any time to pop up the which-key reference — it shows every available follow-up key. While in a chord like Space l the popup shows that chord's sub-bindings.

Search uses smart case: any uppercase character in the query makes the search case-sensitive; otherwise it's case-insensitive.

Bookmarks persist per project under ~/.stem/cache/bookmarks/. The bookmark.list command opens a [Bookmarks] overview; bookmark.clear_all removes them.

In select mode:

• s i <c> — select INSIDE <c>
• s a <c> — select AROUND <c>

In visual mode, drop the s prefix: i <c> / a <c>.

<c> is one of: w word, W WORD, p paragraph, " ' ` string literals, ( [ { < matching pairs (use either bracket).

Typing and backspace replicate at every cursor. Newlines and line-altering operations collapse back to the primary cursor.

On macOS use Cmd, on Linux/Windows use Ctrl:

The highest-frequency actions live as a single key after Space.

Related families live under a chord prefix. Tap Space ; inside any chord to see the contents on screen.

Signature help auto-pops above the cursor in Insert mode when you type ( or ,. Dismissed by ), Esc, or mode change.

The single entry point for opening files. Modal, tree-shaped overlay rooted at the project root.

Space / opens the global search panel. Type into the query field; results populate live across the workspace.

Inside the replace walk:

Replacements happen in open buffers (not directly on disk), so you can undo per-file with Space u and only commit by saving.

Configuration lives in ~/.stem/:

~/.stem/
├── config.json     # User settings
├── plugins/        # Installed plugins (seeded from bundled on first run)
├── lsp/            # Language servers installed via `stem lsp install`
├── cache/          # Background workspace index, etc.
└── logs/           # Debug logs (stem-*.log)

Manage settings from the CLI:

stem config list
stem config get editor.tab_size
stem config set editor.tab_size 2

Or edit ~/.stem/config.json directly:

{
  "editor": {
    "tab_size": 4,
    "insert_spaces": true,
    "line_numbers": "relative",
    "wrap": false,
    "cursor_line": true,
    "auto_pairs": true,
    "format_on_save": false,
    "inline_diagnostics": true,
    "inlay_hints": false,
    "auto_save_backup": true,
    "auto_save_interval_seconds": 30,
    "large_file_threshold_bytes": 5242880,
    "large_file_threshold_lines": 50000,
    "large_file_hard_limit_bytes": 104857600
  },
  "ui": {
    "show_status_bar": true
  },
  "logging": {
    "level": "info"
  }
}

Runtime toggles (via the command palette Space a, or stem config set ...):

When a buffer exceeds large_file_threshold_bytes (default 5 MB) or large_file_threshold_lines (default 50 000), Stem opens it in large-file mode: tree-sitter syntax highlighting, bracket rainbow, LSP requests, and bracket auto-pair are disabled for that buffer. The status bar shows a yellow [LARGE] badge so the quiet behaviour isn't mysterious. Files past large_file_hard_limit_bytes (default 100 MB) are rejected at open time. All three thresholds are per-buffer at open and sticky for the buffer's life — re-open after stem config set ... to re-classify.

While stem is running, every auto_save_interval_seconds (default 30 s) it writes a snapshot of every dirty buffer to ~/.stem/recover/<hash>.bak with a .path sidecar recording the original filename. On the next startup, if any backups survived, the status bar prompts you to run buffer.restore_backups to view them. Disable with stem config set editor.auto_save_backup false.

zig build                                  # Debug
zig build run                              # Debug + run
zig build -Doptimize=ReleaseFast           # Release
zig build test                             # Tests
zig build -Dtarget=x86_64-linux-gnu -Doptimize=ReleaseFast
zig build -Dtarget=x86_64-windows -Doptimize=ReleaseFast    # experimental

src/
├── main.zig           # Entry point and CLI handling
├── cli.zig            # Subcommand dispatch (config, logs, lsp, plugin)
├── kernel/            # Event loop, buffer manager, sessions, commands
├── core/              # Piece-table buffer, editor state, file I/O
├── ui/                # Terminal rendering (vaxis), pickers, themes
├── syntax/            # Tree-sitter integration and language queries
├── services/          # LSP, logging, terminal, global search
├── lsp/               # LSP protocol client and transport
├── plugins/           # Manifest, wasm interpreter, exec runtime
├── config/            # Config schema, keys, persistent storage
├── tools/             # CLI tools (find, vfind, scope, plugin)
└── fuzz/              # Fuzz targets (piece table, state, URIs)

All Zig dependencies are pinned in build.zig.zon:

• libvaxis — terminal UI
• vigil — actor-style message passing
• zls — embedded Zig LSP
• lsp-kit — LSP protocol types
• uucode — Unicode tables
• tree-sitter plus per-language grammars

Bundled plugins are installed into ~/.stem/plugins/<name>/ with a plugin.json manifest. Both wasm modules and child-process exec plugins are supported.

See docs/plugins.md for the full author guide and host internals.

An LSP isn't working for a language. Run stem lsp install <language> and check stem logs. Bump verbosity with stem config set logging.level debug.

Colours look wrong. Make sure your terminal advertises 24-bit colour: export COLORTERM=truecolor.

./install.sh says "no write access to /usr/local". Either re-run with --prefix $HOME/.local (no sudo needed), or grant sudo access.

1. Fork the repository
2. Create a feature branch
3. Make sure zig build and zig build test pass
4. Cross-check at least one other target: zig build -Dtarget=x86_64-linux-gnu
5. Open a pull request

• Plugins — author guide + host internals
• stem.md — long-form reference

MIT License

• Modal-editing ideas from Vim, Kakoune, and Helix
• Built with Zig
• Syntax highlighting powered by tree-sitter