We take a quick look at the features of a new open source text editor called Lapce, its potential impact on the developer ecosystem, and how it compares with existing solutions.
In the world of code editors, where speed, efficiency, and extensibility are critical, a new contender has emerged—Lapce. This open source text editor, written in Rust, is designed to be lightning-fast while maintaining a lightweight footprint. Unlike Electron-based editors such as VS Code, Lapce prioritises native performance without compromising on features. It brings together modern development essentials, including built-in Language Server Protocol (LSP) support, modal editing, and GPU acceleration.
Lapce aims to challenge the status quo by offering a responsive and efficient alternative to mainstream editors. With a focus on speed and minimal resource consumption, it caters to developers who seek a high-performance editing experience.
Why Lapce matters: A fresh take on code editors
The landscape of code editors is vast, with long-established tools like VS Code, Neovim, and Sublime Text dominating the space. However, Lapce sets itself apart with the following attributes.
Speed and efficiency
Lapce is built using Rust, a systems programming language known for its memory safety and speed. Unlike VS Code, which relies on Electron and consumes more resources, Lapce offers a leaner alternative without sacrificing functionality. Its GPU-accelerated UI ensures smooth rendering and instant response times.
Built-in LSP support
One of Lapce’s standout features is its native support for the Language Server Protocol (LSP). This allows for seamless autocompletion, syntax highlighting, and intelligent code suggestions across multiple programming languages, without requiring additional extensions or configurations.
Modal editing for power users
Taking inspiration from Vim, Lapce supports modal editing, enabling developers to switch between different modes for more efficient text manipulation. This feature appeals to users who prefer a keyboard-driven workflow.
Remote development capabilities
Lapce introduces built-in remote development support, similar to VS Code’s SSH integration. Developers can connect to remote servers and edit code as if they were working locally, making it an ideal tool for cloud-based workflows.
Extensibility without bloat
Unlike VS Code’s extension-heavy approach, Lapce is designed with a minimalistic philosophy. While plugins are still being developed, the core editor remains lightweight and fast by default.
Getting started with Lapce
Installing Lapce is a straightforward process. It is available for Linux, macOS, and Windows. To install it, you can download prebuilt binaries from the official website or use package managers:
For macOS using Homebrew, the code is:
brew install lapce
For Linux (Arch-based distributions), use:
pacman -S lapce
For Windows, you can download an installer from the official GitHub releases page.
Once installed, you can launch Lapce from the terminal or applications menu.
Writing code in Lapce
Lapce supports a wide range of programming languages with out-of-the-box LSP integration. Here’s an example of how Lapce enhances development with Rust.
Open Lapce and create a new Rust project:
cargo new osfy-test cd osfy-test lapce .
Open the project in Lapce and start coding as shown in Figure 1.
The built-in LSP provides real-time syntax checking, autocomplete, and inline documentation. To install it, go to the Extensions tab and find the appropriate extension for the language you’re working on. In this example, I’m going to install the Rust extension.
Once that is installed, you will have all the LSP features like autocomplete, documentation highlighting, etc.
Version control with Lapce’s Git integration
Lapce provides a seamless Git integration experience, allowing developers to manage their source control directly from the editor. With its built-in Git panel, users can stage and commit files effortlessly without needing to switch to an external terminal or a separate Git client. The ability to create, switch, and delete branches within the editor makes branch management more intuitive and accessible.
Viewing differences between file versions is made simple with Lapce’s diff viewer, which highlights changes in a clear and concise manner. This feature enables developers to track modifications and review code before committing, ensuring better version control practices. Additionally, pushing and pulling changes to and from remote repositories is a smooth process, eliminating the need for external Git tools. These built-in features make Lapce a compelling option for developers who want a lightweight yet powerful editor with integrated Git support.
How fast is Lapce?
Lapce’s performance has been one of its strongest selling points. Compared to VS Code, it has been shown to consume significantly less memory while offering comparable or better response times. In tests involving large files and complex projects, Lapce consistently outperforms Electron-based editors.
Should you switch to Lapce?
Lapce presents an intriguing alternative to mainstream code editors, especially for developers who value speed, efficiency, and minimal resource consumption. However, its relative newness comes with certain trade-offs that should be considered before making the switch.
One of the biggest advantages of Lapce is its performance. Built with Rust and free from the bloat of Electron-based applications, it offers a responsive experience that is hard to match. If you are frustrated with the sluggishness of VS Code or other resource-heavy editors, Lapce is an excellent alternative. Its built-in support for LSP ensures that language-specific features like autocompletion, syntax checking, and inline documentation work seamlessly without requiring additional configuration.
That said, Lapce is still evolving. While its core functionality is solid, its ecosystem of plugins is not as mature as that of VS Code. Developers who rely on a wide range of extensions for specific workflows may find Lapce’s current plugin support somewhat limiting. Furthermore, as a relatively new project, it may still have occasional bugs or stability issues, though continuous development efforts are addressing these concerns rapidly.
For users who depend heavily on Git integration, Lapce provides a streamlined experience with built-in Git features, making it easy to manage version control directly from the editor. However, those who require advanced Git functionality may still prefer dedicated Git clients or extensions available in other editors.
Ultimately, whether you should switch to Lapce depends on your priorities. If you seek a fast, efficient, and lightweight code editor with modern features, Lapce is a strong contender. However, if you require a vast plugin ecosystem and a long-established user base, you may want to keep an eye on its development while continuing with your current editor. Regardless of whether you make the switch now or in the future, Lapce’s innovative approach signals an exciting shift in the landscape of open source code editors.
Lapce is open source, and its development can be followed on its GitHub repository at https://github.com/lapce/lapce.
