Electron, reimagined
with Rust & WebView
A drop-in Electron replacement built on Rust and the OS platform WebView. Same JavaScript APIs, 99% smaller binary, ~78% less memory — but still early.
Why This Logo?
Gelectron
The Gelectron logo is a visual mashup of what the project actually is: Electron's developer experience wrapped in Firefox-inspired technology.
The atom-like orbital rings pay homage to Electron's iconic branding — because at its core, Gelectron aims to be a drop-in replacement. The warm orange gradient and flame-inspired tones nod to Firefox and the rendering technology that inspired the project.
It's Electron's shape, Firefox's soul. Or at least, that's the idea.
Almost production ready
Gelectron is a non-commercial, community-driven open source project. It's not yet at full production-grade reliability — some Electron APIs are still stubs or incomplete — but it's usable today for many apps, and it's stable enough for most people to build on. It is not affiliated with or endorsed by Electron or Mozilla. Contributions and interest are welcome.
Why Gelectron?
The pitch that convinced us to build it.
3 MB Binary
A compiled Rust binary vs Chromium at 296 MB. Changes how you ship — Docker images, CI pipelines, and downloads all get dramatically smaller.
78% Less Memory
131 MB total RSS vs 586 MB for Electron. No Chromium multi-process overhead means your app uses about a fifth of the RAM.
Same API Surface
Run gelectron . instead of electron .. The familiar BrowserWindow, ipcMain, Menu, dialog APIs you already know. 18 modules working today.
Rust-Powered Core
Window management, native bindings, clipboard, file dialogs, shell operations — all in Rust. Memory-safe, no GC, and fast interop via NAPI-RS bridges.
Platform WebView
Uses the OS native WebView (WebKit on macOS, WebView2 on Windows) for rendering. Stable, hardware-accelerated, and doesn't bundle a browser engine. Long-term goal is Servo.
Open Source
MIT licensed. Non-commercial, community-driven. Contributions welcome. Built in the open on GitHub.
How It Works
If you know Electron, you already know Gelectron.
npx electron .gelectron /path/to/appSame codebase, different engine under the hood.
Installation Guide
Build it, run it, and see what Gelectron can do.
Before you install
Gelectron is pre-1.0. A few Electron APIs aren't implemented yet, and things can change between versions — but many apps run fine today. Give it a try, and expect occasional rough edges.
Install from npm (recommended for macOS & Windows)
npm install -g gelectron-coreInstalls the pre-built native binary for your platform. No Rust toolchain required. This is the easiest way to get started.
Run your Electron app
gelectron-core /path/to/electron-appThat's it! The app runs with Gelectron instead of Electron.
Linux Installation (Build from Source)
Linux requires building from source. The Linux version is not yet published to npm — you'll need Rust and Node.js to build it. This is intentional and doesn't affect publishing the macOS/Windows npm packages.
Clone the repository
git clone https://github.com/mileswolfallen2/gelectron.git
cd gelectronInstall dependencies
npm installRequires Node.js 18+. For the native binary you'll also need Rust 1.75+ — install via rustup.rs.
Build the standalone native binary
cargo build --release -p gelectronProduces target/release/gelectron (~3 MB). Uses tao (windowing) + wry (WebView) — no Chromium, no Servo. First build takes 10–20 minutes; subsequent builds are faster.
Run the demo app
cargo run --release -p gelectron -- demo/Opens a real window with an interactive demo: DOM counter, live clock, animated canvas, CSS grid and flexbox. Validates your build works.
Run your Electron app
cargo run --release -p gelectron -- /path/to/your/electron-appGelectron reads your app's package.json, patches require('electron') to its compatibility layer, and spawns a Node.js child process with a wry WebView window.
Requirements
- macOS/Windows (npm method) — Node.js 18+ (no Rust required)
- Linux (build from source) — Node.js 18+, Rust 1.75+ (via rustup.rs), ~2 GB disk space
- Rendering — WKWebView (macOS) / WebView2 (Windows) / WebKitGTK (Linux)
- Time — npm install is fast; building from source first build can take 10–20 minutes
No Rust? Use the Node.js fallback
Don't want to build the native binary? The CLI can run in a pure Node.js shim mode (no real window — API layer only):
node cli/gelectron.js /path/to/electron-appBuilt on Proven Technology
Gelectron stands on the shoulders of giants — with honesty about what's actually in use today.
Rust
Memory-safe systems language powering the entire native layer. Window management, IPC bridges, native dialogs, clipboard, file dialogs — all Rust.
Platform WebView
Current renderer. Uses the OS native WebView (WebKit on macOS, WebView2 on Windows). Stable, zero-bundle rendering. Long-term target is Servo.
Servo (target)
Mozilla's next-gen browser engine, designed for embedding. Parallel CSS layout, GPU-accelerated rendering. The long-term vision for Gelectron's rendering.
NAPI-RS
Native Rust bindings for Node.js. Powers clipboard (arboard), screen (tao), file dialogs (rfd), shell (open/trash), and nativeTheme detection.
API Support Status
Real status of Electron API compatibility — no overpromising.
| Module | Status | Notes |
|---|---|---|
app |
Full | Lifecycle, dock, badge, GPU info, about panel, window tracking |
ipcMain |
Full | handle, handleOnce, on, once, removeHandler, full EventEmitter |
BrowserWindow |
Partial | Create, show, hide, loadURL, loadFile. Missing: DevTools, print, capturePage |
Menu |
Partial | buildFromTemplate, native setApplicationMenu. Missing: native click events |
clipboard |
Full | Full API: text/HTML/RTF/image/bookmark/find-text, clear, availableFormats, has. Sync FIFO or async bridge |
Notification |
Full | Full Electron API (title/subtitle/body/silent/icon/urgency/timeoutType/actions/hasReply/replyPlaceholder/sound/closeButtonText/toastXml). Native OS integration via notify-rust — macOS Notification Center, Windows Toasts, Linux D-Bus. Events: show/click/action/reply/close/failed |
screen |
Partial | getPrimaryDisplay/getAllDisplays/getCursorScreenPoint via tao bridge |
nativeTheme |
Partial | shouldUseDarkColors, themeSource, shouldSystemUseDarkColors via Rust |
dialog |
Partial | Open/save/message/error dialogs via rfd (Rust) |
shell |
Partial | openExternal, openPath, showItemInFolder via Rust bridge |
ipcRenderer |
Partial | invoke/send/sendSync/on/once. Bridge not always wired |
net |
Partial | fetch delegates to globalThis.fetch. Missing: net.request() |
Tray |
Stub | API exists, does nothing |
autoUpdater |
Partial | setFeedURL/checkForUpdates/downloadUpdate/quitAndInstall; staged apply on relaunch. Packaged apps only |
session |
Stub | All methods are no-ops |
powerMonitor |
Stub | getSystemIdleState always returns 'active' |
4 fully working · 14 partially working · 6 stubs · 32 not started — see full progress
Roadmap
Where Gelectron is headed — with realistic expectations.
Phase 1 — Foundation
- Basic window creation via Platform WebView
- Core Electron API compatibility layer (17 modules)
- IPC between main and renderer
- Rust bridge for clipboard, screen, nativeTheme
- CLI entry point (
gelectron .)
Phase 2 — Core APIs
- Flesh out partial modules to full
- Native OS notifications
- BrowserWindow feature parity (DevTools, navigation)
- Proper session and webRequest support
Phase 3 — Ecosystem
- autoUpdater integration ✓ shipped
- Protocol handler registration
- Native Node.js module support
- Packaging & distribution tools ✓ shipped
Phase 4 — Production Ready
- Full API parity with Electron
- Performance optimization
- Servo rendering integration
- Cross-platform CI/CD
- Documentation & guides
Benchmarks
Performance comparisons between Gelectron and Electron — from the bench page. Full methodology and caveats on the detailed benchmarks page.
View Detailed Benchmarks →Results are 10-run averages. Gelectron uses Platform WebView + Node.js in main process only. Electron uses Chromium + Node.js in renderer. Take these as directional signals.
No Node.js in the renderer. Gelectron's renderer has no Node.js integration. Memory and process metrics are measured from the main process (Node.js 26.3.1) and the platform WebView. This is fundamentally different from Electron, where Node.js runs inside the renderer.
Gelectron
benchmarks.html — 10-run averagesElectron
benchmarks.html — 10-run averagesBoth benchmarks ran on the same machine (darwin arm64). Gelectron used Platform WebView + Node.js 26.3.1 (main process only). Electron used Chromium v43.2.0 with Node.js in the renderer. Results are 10-run averages with min/max reported. These numbers will change as both projects evolve. Full details on the benchmarks page.
Frequently Asked Questions
Got questions? We've got answers — candid ones.
Gelectron is an open-source alternative to Electron that replaces Chromium with the OS Platform WebView and adds a Rust core for native operations. It aims to be a drop-in replacement — you run gelectron . instead of electron .. It's still maturing and a few APIs are incomplete, but many apps run fine.
Electron bundles a full copy of Chromium (~296 MB) and consumes significant memory (~586 MB total RSS). Gelectron aims to provide the same developer experience with a 3 MB binary and 131 MB memory footprint. The trade-off: fewer APIs work, no Node.js in the renderer, and a less mature ecosystem.
Not fully production-ready yet. Gelectron is a non-commercial, community-driven project, and 32 of 56 Electron modules aren't implemented. For many apps it works well today, but expect rough edges and occasional API changes. We'll announce when it reaches full stability.
Currently: Platform WebView. Gelectron uses the OS native WebView (WebKit on macOS, WebView2 on Windows) for rendering. Long-term target: Servo. The Rust-native rendering engine from Mozilla is the vision, but it's not ready for embedding in production apps yet. The Platform WebView gives us a stable, zero-bundle rendering layer in the meantime.
Eventually, yes — that's the goal. Simple apps that use only BrowserWindow, ipcMain, Menu, and dialog may work today. Apps using Tray, session, native Node.js modules, or calling require() in the renderer will not work. autoUpdater works for packaged apps with a hosted update feed.
The core is written in Rust, using NAPI-RS bindings for Node.js interop, tao for window management, and a JavaScript compatibility layer that maps Electron's API surface to Gelectron's Rust internals. The renderer is the OS Platform WebView.
Currently, Gelectron targets macOS, Linux, and Windows. Cross-platform support leverages Rust's cross-compilation story and each platform's native WebView.
Absolutely! Gelectron is MIT licensed and open source. Check out the GitHub repo to explore the code, open issues, or submit pull requests. All contributions are welcome — even just starring the repo helps.
On current benchmarks (10-run averages): Gelectron is 99% smaller (3 MB vs 296 MB), uses ~78% less memory (131 MB vs 586 MB), and is ~14% faster on renderer operations (DOM, Canvas, JSON, sort, recursion). However, Electron is 83% faster on DOM querySelector, has a mature DevTools experience, and supports far more APIs. See the full benchmarks page for details.
No. Gelectron's renderer has no Node.js integration — no require(), no fs, no native modules. All Node.js interaction goes through IPC to the main process. This is more secure (no Node.js injection attacks) but requires restructuring preload scripts for existing Electron apps.
Gelectron is a non-commercial passion project with no firm timeline. The roadmap outlines the major phases, but progress depends on contributor interest. Follow the repo for updates. If you'd like to help accelerate it, contributions are welcome.
Already being built with
Libraries, apps, and companies are shipping on Gelectron today.
See the showcase →
Interested in the project?
Star the repo, open an issue, or just follow along. Gelectron is early, but the vision is real.
Check it out on GitHub →