NEO Emacs

Name: NEO Emacs — Download free. GPU-Powered Editor
Availability: InStock
Rating: 5 (1 reviews)
Author: Eval Exec

NEO Emacs — Free Download. GPU-Powered Editor

NEO Emacs is a reimplementation of the Emacs editor built around a GPU display engine and a Rust core, designed to preserve full compatibility with the existing Emacs ecosystem while replacing the underlying C machinery. It renders text, images, inline video, and animated effects through wgpu across Vulkan, Metal, DX12, and GL backends, and it exposes the entire frontend, from render effects down to GPU shaders written in WGSL, to Elisp. The same binary runs as a graphical application or inside a terminal via neomacs -nw.

★★★★★

5.0(1 ratings)

Download NEO Emacs (Official links)

File size: 55.6 MB

The latest version of NEO Emacs is: 0.0.19

Operating system: Windows, MacOS, Linux

Languages: English

Developer: Eval Exec

Price: $0.00 USD (Open Source (GPL-3.0))

GPU Display Engine. The rendering pipeline is built on wgpu and targets Vulkan, Metal, DX12, and GL backends. Approximately four thousand lines of Rust replace roughly fifty thousand lines of the original xdisp.c display code. Text shaping, glyph rasterization, image compositing, and effect rendering are performed on the GPU, which keeps frame pacing stable at display refresh rate and removes the CPU-bound redraw bottlenecks found in the legacy C implementation.
Full Ecosystem Compatibility. Existing init.el files, installed packages, keybindings, and editing habits continue to function without modification. GNU Emacs itself is used as a test oracle, meaning each rewritten subsystem is diffed against the reference implementation to confirm identical behavior. Real-world configurations, including Doom Emacs, serve as the daily test bed for regression detection.
Rich Media Buffers. Buffers can host inline 4K video through a typed Rust GStreamer integration with VA-API hardware decoding on Linux. GPU-decoded images are displayed without copying through system memory, and DMA-BUF paths keep frame data resident on the GPU. Where native interop is unavailable, typed fallback paths handle decoding and presentation instead of failing silently.
Embedded WebKit Browser. A WPE WebKit component runs inside an Emacs buffer, allowing web content to be displayed alongside source code, documentation, or notes. Navigation, rendering, and input handling occur within the editor window rather than in an external application, which keeps documentation lookups and web-based workflows inside the same session.
GPU Terminal Emulator. A terminal emulator rendered on the GPU is available as a buffer. It handles text output, color, and cursor positioning through the same rendering path as other buffer content, so terminal sessions inherit the frame pacing and visual effects of the display engine instead of relying on a separate CPU renderer.
Cursor Modes. Eight cursor modes control the appearance and motion behavior of the point. Each mode is configurable from Elisp, which means cursor rendering can be adjusted per buffer, per mode, or globally depending on the editing context and the visual feedback required for a given task.
Scroll Effects. Twenty-one scroll effects govern how buffer content moves when the viewport shifts. Effects run at display refresh rate and are selected through Elisp configuration. The scroll system operates independently of the text layout layer, so changing an effect does not require recompiling or restarting the editor.
Buffer Transitions. Ten buffer transition animations control how one buffer replaces another in the window. Transitions are driven by the display engine and are configured from Elisp. They apply to buffer switching, window changes, and split adjustments, giving visual continuity when the visible content changes.
Elisp-Accessible Frontend. In GNU Emacs, extensibility stops at the boundary of the C display engine. NEO Emacs exposes the full frontend to Elisp, including render effects and GPU shaders written in WGSL. Custom rendering behavior, visual effects, and shader logic can be defined and modified from the same configuration language used for editing behavior.
Pure-Rust Core. The Elisp evaluator, bytecode virtual machine, garbage collector, portable dump, and editor internals are implemented in Rust. No C components remain in the core. Memory safety is enforced by the language, which removes entire classes of bugs associated with manual memory management in the legacy subsystems.
GUI and Terminal Modes. One binary provides both graphical and terminal operation. Running neomacs -nw starts the editor in a TTY, while the default invocation starts the GPU-rendered interface. Configuration, packages, and keybindings are shared between both modes, so switching environments does not require separate setup.
Multi-Threaded Elisp and Concurrent GC. True multi-threaded Elisp execution and a concurrent zero-pause garbage collector are under development. These changes target the removal of stop-the-world pauses during collection and the introduction of parallel evaluation, which affects responsiveness during long-running Lisp workloads.

NEO Emacs is developed by the team behind the neomacs.org project. The editor was created as a response to limitations in the C core of GNU Emacs, particularly the display engine, which had accumulated decades of complexity and was difficult to extend from Elisp. Development started in the 2020s, with GNU Emacs serving as the behavioral reference for every rewritten subsystem. The project is written in Rust, including the Elisp evaluator, bytecode VM, garbage collector, and portable dump. The GPU display engine is built on wgpu, with GStreamer, VA-API, and WPE WebKit integrated for media and browsing capabilities.