awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com

Modern Rust Modal Text Editors

Ranking updated Jun 30, 2026

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.

Modern Rust Modal Text Editors

Find the best repos with AI.We'll search the best matching repositories with AI.
  • helix-editor/helixhelix-editor avatar

    helix-editor/helix

    44,911View on GitHub↗

    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.

    RustLanguage Server ClientsLanguage Server IntegrationsModal Editing Interfaces
    View on GitHub↗44,911
  • lapce/lapcelapce avatar

    lapce/lapce

    38,569View on GitHub↗

    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.

    RustGPU-Accelerated UI RenderingLanguage Server ClientsLanguage Server Integrations
    View on GitHub↗38,569
  • zed-industries/zedzed-industries avatar

    zed-industries/zed

    85,338View on GitHub↗

    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.

    RustGPU-Accelerated UI RenderingLanguage Server Protocol ClientsLanguage Server Protocols
    View on GitHub↗85,338
  • sinelaw/freshsinelaw avatar

    sinelaw/fresh

    5,914View on GitHub↗

    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.

    RustLanguage Server IntegrationsLanguage Server ProtocolsMulti-Cursor Editing
    View on GitHub↗5,914
  • shougo/deoplete.nvimShougo avatar

    Shougo/deoplete.nvim

    5,906View on GitHub↗

    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.

    PythonLanguage Server ClientsLanguage Server IntegrationsLanguage Server Protocol Clients
    View on GitHub↗5,906
  • doomemacs/doomemacsdoomemacs avatar

    doomemacs/doomemacs

    22,264View on GitHub↗

    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.

    Emacs LispLanguage Server ClientsLanguage Server ClientsLanguage Server Integrations
    View on GitHub↗22,264
  • b4winckler/macvimb4winckler avatar

    b4winckler/macvim

    5,049View on GitHub↗

    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.

    CModal EditorsVi Modal Editing
    View on GitHub↗5,049
  • onivim/oni2onivim avatar

    onivim/oni2

    7,854View on GitHub↗

    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.

    ReasonLanguage Server ClientsLanguage Server IntegrationsModal Editing Systems
    View on GitHub↗7,854
  • dense-analysis/aledense-analysis avatar

    dense-analysis/ale

    13,966View on GitHub↗

    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.

    Vim ScriptLanguage Server ClientsLanguage Server Protocol ClientsLanguage Server Protocols
    View on GitHub↗13,966
  • vscodevim/vimVSCodeVim avatar

    VSCodeVim/Vim

    15,160View on GitHub↗

    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.

    TypeScriptModal Editing SystemsMulti-Cursor EditingMulti-Cursor Editing Systems
    View on GitHub↗15,160
  • w0rp/alew0rp avatar

    w0rp/ale

    14,005View on GitHub↗

    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.

    Vim ScriptLanguage Server IntegrationsLSP Clients
    View on GitHub↗14,005
  • mawww/kakounemawww avatar

    mawww/kakoune

    10,938View on GitHub↗

    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.

    C++Modal Editing SystemsModal EditorsMulti-Cursor Editing
    View on GitHub↗10,938
Compare the top 10 at a glance
RepositoryStarsLanguageLicenseLast push
helix-editor/helix44.9KRustMPL-2.0Jun 14, 2026
lapce/lapce38.6KRustApache-2.0Jun 10, 2026
zed-industries/zed
85.3K
Rust
NOASSERTION
Jun 16, 2026
sinelaw/fresh5.9KRustgpl-2.0Feb 20, 2026
shougo/deoplete.nvim5.9KPythonNOASSERTIONJun 5, 2024
doomemacs/doomemacs22.3KEmacs LispMITJun 16, 2026
b4winckler/macvim5KC—Aug 5, 2017
onivim/oni27.9KReasonMITAug 17, 2022
dense-analysis/ale14KVim Scriptbsd-2-clauseFeb 17, 2026
vscodevim/vim15.2KTypeScriptMITJun 17, 2026

Related searches

  • a hands-on project for learning systems programming
  • a terminal UI library for building TUIs in Rust
  • a cross-platform GUI framework for Rust desktop apps
  • a game engine written in Rust
  • a project-based path to learning Rust
  • a library for building Rust CLI applications
  • a keyboard driven file manager for terminal
  • a tiling window manager for desktop workflows