For a modern modal text editor written in Rust, the first results are helix-editor/helix (Helix is a Rust-based terminal modal text editor with deep structural parsing integration tree-sitter and LSP, perfectly matching your search for a modern, Vim-like editor with built-in language intelligence and extensibility), lapce/lapce and zed-industries/zed (Zed is an open-source, Rust-based code editor with built-in Vim emulation, LSP integration, tree-sitter highlighting, a GPU-accelerated renderer, a terminal, and an extension system—exactly the modern modal editor you're looking for). sinelaw/fresh and shougo/deoplete.nvim round out the shortlist. Compare the match explanations and check the project documentation against your requirements.
High-performance text editors built with Rust that feature modal editing workflows for efficient code manipulation.
Helix is a terminal-based modal text editor designed for efficient code manipulation and navigation. It centers on a selection-first editing model, where operations are performed on active ranges rather than individual cursor positions, allowing for precise control over text and code structures. The editor distinguishes itself through deep integration with structural parsing and language intelligence. By utilizing an incremental parsing library, it builds concrete syntax trees that enable advanced features like structural code navigation, intelligent indentation, and syntax-aware text object
Helix is a Rust-based terminal modal text editor with deep structural parsing integration (tree-sitter and LSP), perfectly matching your search for a modern, Vim-like editor with built-in language intelligence and extensibility.
Lapce is a high-performance text editor built with Rust that utilizes hardware acceleration for fast rendering and responsiveness. It functions as a modal text editor with Vim-style keybindings to minimize hand movement, an LSP client for language intelligence, and a remote development environment for editing files and executing code on distant servers. The editor features an extensible architecture based on the WebAssembly System Interface, allowing it to execute plugins compiled to WASI for cross-language functionality. It further distinguishes itself by implementing the Debug Adapter Proto
Lapce is a modern, modal text editor written in Rust with Vim-style keybindings, LSP support, a WASI-based plugin system, and GPU-accelerated rendering, covering most of the requested features — though tree-sitter syntax highlighting and multiple cursors aren't explicitly confirmed, it squarely fits the category.
Zed is an AI-native, high-performance code editor designed for extreme responsiveness and keyboard-centric workflows. It functions as an extensible text processing workspace that integrates autonomous agents and predictive models directly into the development environment to automate complex engineering tasks, refactoring, and code generation. The editor distinguishes itself through a GPU-accelerated rendering pipeline and an asynchronous multi-threaded architecture that ensures low-latency interaction even with large-scale projects. It features built-in support for real-time, multi-user colla
Zed is an open-source, Rust-based code editor with built-in Vim emulation, LSP integration, tree-sitter highlighting, a GPU-accelerated renderer, a terminal, and an extension system—exactly the modern modal editor you're looking for.
Zed is a terminal-based code editor built in Rust that provides a full-featured editing experience with familiar keybindings, mouse support, and multiple cursors. It runs entirely in the terminal while offering capabilities typically found in graphical editors, including split panes, a command palette, and integrated language server protocol support for real-time diagnostics, completions, go-to-definition, and code actions across multiple languages. The editor distinguishes itself through a plugin system that runs sandboxed TypeScript plugins in a QuickJS runtime, with an asynchronous bridge
This repository offers a terminal-based code editor in Rust with Language Server Protocol support, a plugin system via sandboxed TypeScript scripts, and multiple cursors, fitting the description of a modern modal editor; however, it does not explicitly advertise Vim keybindings or a built-in terminal emulator.
Deoplete.nvim is an asynchronous completion engine and framework for Neovim and Vim8. It functions as a non-blocking system for fetching and displaying text suggestions, serving as a modular extension that integrates multiple external completion sources without freezing the editor user interface. The project operates as a Language Server Protocol client, bridging the editor to external language servers to provide context-aware, type-safe completions. It further distinguishes itself by supporting intelligent text prediction through the integration of machine learning engines and language-speci
Deoplete.nvim is a completion engine and LSP client plugin for Neovim and Vim, not a standalone modal text editor written in Rust—it's a building block for editors, not the editor itself.
This project is a modular configuration framework for the Emacs text editor, designed to provide optimized defaults and a curated ecosystem of plugins. It functions as a comprehensive environment that structures complex editor settings into a reproducible and stable workspace. The framework distinguishes itself through a declarative package management system that pins dependencies to ensure consistency across different machines. It incorporates a modal editing layer that replicates keyboard-driven navigation and text manipulation workflows, alongside a rule-based engine that automates the lif
Doom Emacs is a modular configuration framework that adds Vim-like modal editing to Emacs via the Evil layer, but it is written in Emacs Lisp and extends an existing editor rather than being a standalone modal editor implemented in Rust.
MacVim is a native Cocoa application that implements the Vim modal text editor as a graphical user interface on macOS. It integrates the editor engine directly into a native window and event loop, allowing it to operate without a terminal emulator. The project functions as both a programming text editor and a hexadecimal binary editor. It provides tools for modifying raw binary data via a visual hexadecimal grid and applying patches to binary files. The editor features modal input handling, pattern-based syntax highlighting, and rectangular block selection. Additional capabilities include mu
MacVim is a native macOS modal text editor based on Vim, but it is written in C and not in Rust, so it does not satisfy the key requirement for a Rust-based editor with modern features like LSP and tree-sitter.
Oni2 is a high-performance, extensible text editor and project-based file manager. It functions as a modal code editor, utilizing a keyboard grammar of verbs and motions to navigate and modify source code without a mouse. It also serves as an LSP client, integrating Language Server Protocol servers to provide code completion, symbol navigation, and refactoring. The editor distinguishes itself by acting as a VSCode extension host, allowing it to load and execute language servers and debuggers from the VSCode ecosystem. It provides a programmable environment where custom functionality is implem
Oni2 is a modal text editor with LSP support and a VSCode extension host, but it is built in Reason rather than Rust, so it does not satisfy the requirement for a Rust-based editor.
Ale is an asynchronous code analysis tool and integrated development environment plugin designed for lightweight text editors. It functions as a language server protocol client, enabling real-time code intelligence and diagnostic feedback by running analysis tasks in the background to ensure the editor interface remains responsive during intensive operations. The plugin utilizes an event-driven architecture to monitor text buffers and trigger linting or formatting routines automatically. It distinguishes itself through a modular extensibility framework that supports a wide range of language-s
ALE is a plugin for Vim and Neovim that provides asynchronous linting and LSP integration, but it is not a standalone text editor—it extends existing editors rather than being one itself, which doesn't match the search for a Rust-based modal editor.
This project is a Vim keybinding emulation for Visual Studio Code. It implements modal text editing to separate navigation and content creation through specialized modes, reducing reliance on the mouse. The emulator supports custom IDE workflows by importing standard configuration files and remapping keyboard shortcuts. It integrates with external processes to handle complex commands and reproduces logic from common plugins for surrounding characters, commenting, and rapid motion. The capability surface includes keyboard-driven navigation using text objects, markers, and character sequences.
This is a Vim keybinding extension for Visual Studio Code, not a standalone text editor written in Rust — it offers modal editing and LSP integration through the host IDE, but it doesn't provide its own terminal, tree-sitter, or GPU rendering, and its implementation language is TypeScript, not Rust.
Ale is a Neovim LSP client and asynchronous linter wrapper designed to integrate language servers and syntax checkers into the editor. It provides infrastructure for background syntax validation and automated code fixing without blocking the editor interface. The project implements the Language Server Protocol to enable advanced semantic navigation, including symbol renaming, definition jumping, and the application of automatic refactoring changes. It functions as an automatic code fixer that applies formatting and repairs based on feedback from linting tools and language servers. The plugin
ALE is a Neovim plugin for LSP and linting, not a standalone text editor — it extends an existing Vim-based editor rather than being the Rust-implemented modal editor you are looking for.
Kakoune is a scriptable, modal text editor for the terminal that employs a client-server architecture. This model allows multiple terminal windows to connect to a single editing session, providing a programmable environment for managing source code and text. The editor is distinguished by its selection-first logic, where a text region must be predefined before a command is applied. It leverages regular expressions to manage multiple cursors and perform bulk edits across complex text patterns, and it integrates deeply with the shell by piping selections through external programs and filters.
Kakoune is a modal text editor with multiple cursors and scriptability, but it is written in C++, not Rust, and does not mention LSP or tree-sitter support, so it does not satisfy the need for a Rust-based modern modal editor.
| Repository | Stars | Language | License | Last push |
|---|---|---|---|---|
| helix-editor/helix | 44.9K | Rust | MPL-2.0 | |
| lapce/lapce | 38.6K | Rust | Apache-2.0 | |
| zed-industries/zed |
| 85.3K |
| Rust |
| NOASSERTION |
| sinelaw/fresh | 5.9K | Rust | gpl-2.0 |
| shougo/deoplete.nvim | 5.9K | Python | NOASSERTION |
| doomemacs/doomemacs | 22.3K | Emacs Lisp | MIT |
| b4winckler/macvim | 5K | C | — |
| onivim/oni2 | 7.9K | Reason | MIT |
| dense-analysis/ale | 14K | Vim Script | bsd-2-clause |
| vscodevim/vim | 15.2K | TypeScript | MIT |