I need a code editor that is lightweight and does not use Electron.

Here are the best lightweight, native (non-Electron) code editors available, broken down by whether you want a traditional GUI or a terminal-based interface:

Graphical (GUI) Editors

• Sublime Text : Built completely on custom C++ architecture, it is lightning-fast, uses minimal RAM, starts up instantly, and handles massive files without breaking a sweat. It supports extensive packages, though it is a paid product with a generous evaluation period.
• Geany : A mature, lightweight GTK-based text editor and IDE that supports over 50 languages. It provides a traditional multi-window/tab layout with project management, syntax highlighting, and a plugin system while staying extremely frugal with system resources.
• Lapce : A modern, blazing-fast code editor written entirely in Rust. It features GPU-accelerated rendering, built-in LSP (Language Server Protocol) support for intelligent code completion, and an optional remote-development mode without the massive memory footprint of web-technologies.
• Kate : The KDE Advanced Text Editor is feature-rich, fast, and remarkably lightweight for how much power it packs (including multi-document handling, a built-in terminal, and deep syntax folding). While part of the KDE ecosystem, it runs great across platforms.

Terminal-Based Editors

• Neovim : An aggressive refactor of Vim, Neovim is hyper-extensible, runs directly in your terminal, consumes virtually zero overhead, and transforms into a full-fledged IDE with modern Lua plugins and built-in LSP support.
• GNU Nano : The ultimate no-frills, lightweight text editor pre-installed on almost every Unix/Linux system. It is ideal for quick configuration changes and lightweight script editing without leaving the shell.

To help narrow down the best choice for you, tell me:

• What operating system are you using (Windows, macOS, or Linux)?
• Do you prefer a GUI window or a terminal-based interface?

If your priorities are lightweight + native + no Electron, I’d shortlist these:

• Zed — best overall GUI choice. It’s written in Rust, uses a native GPU-accelerated architecture rather than Electron, and supports LSP, Git, debugging, terminals, extensions, and Vim/Helix-style editing. It runs on macOS, Linux, and Windows.
• Helix — best if you don't need a GUI. A very fast terminal editor written in Rust, with built-in language-server support, Tree-sitter syntax highlighting, multiple selections, and modal editing.
• Neovim — best for maximum extensibility and minimal resource usage. It's terminal-first and extremely configurable, although getting it set up as a full IDE takes more work.
• Gram — an interesting newer native GUI alternative. It started as a Zed fork and aims for a more traditional, hand-focused coding experience. It has LSPs, Git, DAP debugging, SSH remote development, Vim/Helix modes, and explicitly avoids telemetry and proprietary server components.

My pick

Try Zed first if you want something that feels like a modern VS Code replacement without Electron. It's probably the closest match to "lightweight, but still a full-featured graphical code editor."

If by lightweight you mean "I want something that uses almost no RAM and starts instantly", I'd go Neovim or Helix instead.

If you tell me your OS (Windows/macOS/Linux) and whether you want GUI or terminal, I can narrow this down to the best 2–3 options.

If you want to escape heavy Electron-based frameworks (like VS Code or Pulsar) and want something genuinely snappy, native, and light on RAM, you have several fantastic cross-platform and platform-specific options:

• Sublime Text — A proprietary, incredibly fast GUI editor written in custom C++ components. It launches instantly, handles massive files without stuttering, consumes a tiny fraction of the memory VS Code uses, and supports a rich plugin ecosystem.
• Zed — A high-performance, modern code editor written in Rust. It features blazing-fast startup times, minimal input latency, built-in collaboration features, and native GPU acceleration, making it feel radically lighter than web-technology-based editors.
• Neovim / Vim — The ultimate lightweight, terminal-based keyboard-centric editor. With modern built-in LSP (Language Server Protocol) support, Neovim matches the code intelligence of heavy IDEs while operating on mere megabytes of RAM.
• Geany — A lightweight, cross-platform GTK-based IDE/editor. It provides a traditional file-tree and tabbed interface, supports loads of languages, loads in a blink, and stays completely out of your way.
• Notepad++ — The go-to lightweight choice if you are on Windows. Written in C++ using Win32, it uses virtually no resources and opens files instantaneously.

To help narrow down the best fit, let me know:

• What operating system (Windows, macOS, Linux) are you on?
• Do you prefer a traditional GUI window or a terminal-based workflow?

Yes. If lightweight + no Electron are your priorities, I’d shortlist these:

• lite-xl.com — probably the best fit if you want really lightweight. It’s written in C/Lua, the bundle is under 5 MB, and it supports autocomplete, split panes, LSP, terminals, Git, debugging, and plugins.
• zed.dev — best if you want something closer to a modern VS Code replacement. It’s written in Rust with its own GPU-accelerated UI framework rather than Electron, and supports Windows, Linux, and macOS.
• Helix — excellent if you're comfortable with a terminal/TUI editor. It's extremely lightweight and has modal editing and built-in LSP support, but it isn't a traditional GUI editor.
• Neovim — the obvious choice if you're happy customizing your editor. Very lightweight, native, and enormously extensible, though there's a learning curve.

My recommendation

Try Lite XL first if your definition of lightweight is “I want the editor to barely exist until I need it.” Its base installation is tiny and it can still be turned into a fairly capable IDE through plugins.

If you want VS Code-like functionality without Electron, I'd pick Zed. It is considerably more feature-rich out of the box while still being native/Rust-based.

If you tell me your OS (Windows/Linux/macOS) and whether you need LSP, Git, debugging, extensions, and an integrated terminal, I can narrow this down to the best 2–3 options.

Absolutely. If your main requirements are lightweight + no Electron, these are strong choices:

• lite-xl.com — My top GUI recommendation. Written in C/Lua, extremely small (the project says the bundle is under 5 MB), fast, cross-platform, and extensible with Lua plugins. It has autocomplete, split panes, syntax highlighting, etc.
• geany.org — Excellent if you want something closer to a traditional IDE. GTK-based rather than Electron, with syntax highlighting, completion, project features, an embedded terminal, and plugins.
• helix-editor.com — Best if you're happy with a terminal editor. Written in Rust, with built-in LSP, Tree-sitter, multiple selections, fuzzy finding, and project search. It explicitly has no Electron.
• scintilla.org — Very lightweight and old-school. Based on Scintilla, with native Win32/GTK support rather than Electron. Particularly good if you prioritize speed and simplicity over modern IDE features.

What I'd pick

If you want something that feels closest to VS Code but without Electron, I'd start with Lite XL. If you tell me your OS (Windows/macOS/Linux) and whether you need LSP, Git integration, debugging, or extensions, I can narrow it down to 2–3 options.

If you are tired of resource-heavy, Electron-based applications like VS Code and want something snappy, instant-loading, and light on memory, several fantastic native alternatives avoid Electron entirely:

• Sublime Text — Built with a custom C++ UI toolkit, it is legendary for its blazing-fast startup time, minuscule RAM footprint, and ability to open massive files instantly without breaking a sweat. It's paid software, but the evaluation version lasts indefinitely.
• Zed — Created by the original authors of Atom (the very project that birthed Electron!), the team completely pivoted. Zed is written from scratch in Rust and renders using your GPU. It offers modern LSP (Language Server Protocol) support, feels instantaneous, and is open-source/free.
• Neovim — If you are open to a terminal-based or keyboard-driven workflow, Neovim is exceptionally lightweight. With built-in LSP support, it matches the code-intelligence of heavy IDEs while consuming negligible resources.
• Notepad++ — A classic, ultra-lightweight, native Win32 application for Windows users. It lacks a "modern web app" look, but it starts up instantly and handles quick script edits effortlessly.
• Helix — A modern, modal terminal editor (similar to Neovim) written in Rust that comes with built-in LSP support out of the box, meaning zero complex configuration is required to get intelligent code completion and diagnostics.

To help narrow down the best fit, tell me:

• What operating system are you using (macOS, Windows, Linux)?
• Do you prefer a traditional GUI with tabs/mouse support, or a keyboard-driven/terminal environment?

Absolutely. If “lightweight + no Electron” is the priority, I’d shortlist these:

• Lite XL — my pick for maximum lightweightness. It’s written in C/Lua, is designed to be small and fast, and runs on Windows, Linux, and macOS. It can be extended with LSP, terminal, Git, formatters, debugging, etc.
• Helix — best if you're comfortable with a terminal editor. Written in Rust, explicitly has “No Electron”, and includes Tree-sitter-based syntax/code analysis and built-in LSP functionality.
• Zed — best modern GUI alternative. Zed is written from scratch in Rust using its own GPU-accelerated UI framework rather than Electron. It has LSP, Git, debugging, extensions, AI features, and is available on macOS, Linux, and Windows.

My recommendation

If you're coming from VS Code and want something that still feels like a conventional GUI editor:

Zed → Lite XL

If your overriding goal is “use as little RAM/CPU as possible”:

Lite XL → Helix

If you tell me your OS (Windows/Linux/macOS) and whether you need LSP, Git, debugger, terminal, and/or AI, I can narrow it down to the best 2–3 options.

If you want to step away from resource-heavy Electron apps (like VS Code or Cursor), there are fantastic high-performance, native options available depending on your workflow style.

Here are the best lightweight, non-Electron code editors categorized by how you like to work:

1. The Speed King (Modern GUI)

• • Tech Stack: Written in Rust, using a custom GPU-accelerated UI framework (GPUI).
  • Why it’s great: Built by the original creators of Atom (who wanted to fix the performance limits of Electron). It has virtually zero input latency, opens instantly, supports Language Server Protocol (LSP) out of the box, and features built-in blazing-fast collaboration.
  • OS: macOS and Linux (Windows support in development/preview).

2. The Classic Utility Powerhouse

• • Tech Stack: Custom C++ core and proprietary UI toolkit.
  • Why it’s great: Legendary for a reason. It consumes a tiny fraction of the RAM that VS Code uses, handles massive multi-gigabyte log files or codebases without flinching , and has an instantaneous startup time. It is infinitely extensible via Python plugins.
  • OS: Windows, macOS, Linux.

3. The Terminal & Modal Speedsters

• • Tech Stack: C and Lua (Extensible via Lua).
  • Why it’s great: If you are willing to embrace keyboard-driven, modal editing, Neovim is unmatched . Modern Neovim has built-in LSP support , asynchronous plugin loading, and turns your code editor into a feather-light environment that runs comfortably inside any terminal or dedicated GUI wrapper (like Neovide).
  • OS: Cross-platform (Windows, macOS, Linux).

4. Lightweight Traditional Desktop Editors

• Kate (KDE Advanced Text Editor) or
  • Tech Stack: C++/GTK or Qt native widgets.
  • Why it’s great: Geany is a fast, stable, and lightweight environment that acts almost like an IDE while relying on GTK libraries. Kate offers advanced features like split-views, embedded terminals, and robust syntax highlighting while remaining exceptionally light on system resources compared to web-tech wrappers.
  • OS: Linux, Windows, macOS.

To help narrow down the best choice for you, tell me:

• What programming languages or frameworks do you primarily work with?
• Do you prefer a traditional mouse-and-GUI interface or a keyboard-driven/modal workflow?

If you want to ditch Electron for something fast, responsive, and light on system resources, several excellent native options range from modern GPU-accelerated GUIs to classic modal terminal powerhouses. [1][2]

Modern GUI Editors (Fast & Lightweight)

• Zed Editor
  • The Tech: Built in Rust with GPU-accelerated rendering. Created by the original authors of Atom (who explicitly abandoned web tech/Electron because it was too slow).
  • Why it's great: Blazing fast startup times, microscopic memory footprint, native feel, built-in LSP (Language Server Protocol) support, and real-time collaboration features.
  • Platforms: macOS and Linux (Windows version in development). [1][2]
• Sublime Text
  • The Tech: Custom C++ core with a proprietary UI toolkit.
  • Why it's great: The gold standard for a snappy, non-bloated proprietary GUI text editor. It opens massive files instantly, uses virtually no RAM, and features a robust Python plugin ecosystem.
  • Platforms: Windows, macOS, Linux. [1][2][3]
• Geany
  • The Tech: Written in C using the GTK toolkit.
  • Why it's great: A mature, lightning-fast text editor that acts like a lightweight IDE. It loads in a fraction of a second and supports project management, code folding, and basic terminal integration without heavy overhead.
  • Platforms: Windows, Linux, macOS.

Terminal-Based Editors (Maximum Speed & Efficiency)

• Neovim
  • The Tech: Extensible Vim fork optimized for performance.
  • Why it's great: Runs directly in your terminal, consuming negligible memory. With built-in LSP support, treesitter syntax highlighting, and Lua configurations, it matches the utility of modern IDEs while remaining completely keyboard-driven and instantaneous.
  • Platforms: Cross-platform (Windows, macOS, Linux). [1]
• Micro
  • The Tech: Written in Go.
  • Why it's great: If you like terminal editors but hate learning Vim keybindings, Micro gives you a modern terminal experience with standard shortcuts like Ctrl+C, Ctrl+V , and full mouse support in an ultra-lightweight package.
  • Platforms: Cross-platform (Windows, macOS, Linux).

To help narrow down the best fit, tell me:

• Do you prefer a traditional mouse-driven GUI or a keyboard-first terminal workflow?
• What programming languages will you primarily be writing in?

Yes. If your priorities are lightweight + no Electron, I’d shortlist these:

• lite-xl.com — best for a traditional lightweight GUI editor. It’s written in C/Lua, the bundle is under 5 MB, and it runs on Windows, Linux, and macOS. It supports autocomplete, multiple selections, split panes, plugins, and can be configured into a minimal IDE with LSP support.
• helix-editor.com — best if you’re comfortable in the terminal. It’s written in Rust, has built-in LSP, Tree-sitter, multiple selections, and explicitly does not use Electron, JavaScript, or VimScript.
• zed.dev — best if you want something more VS Code-like. Zed is a native Rust/GPU-accelerated editor rather than an Electron app, and is available on macOS, Linux, and Windows. It has LSP, Git, debugging, extensions, collaboration, and AI features.

My recommendation

If absolute lightness is the goal: Lite XL.

If you want powerful code editing with minimal resource usage and don't mind Vim-style editing: Helix.

If you want a modern GUI editor that feels closest to a full IDE without Electron: Zed.

If you tell me whether you're on Windows, macOS, or Linux, I can narrow this down further—including RAM usage, startup speed, LSP support, plugins, Git, and debugger support.