I started Neomacs because I love Emacs, I respect Emacs, and I want to make it better. — Eval Exec

✨ "While other editors can save your files, only Emacs can save your soul." ✨

NEOMACS - The Future of Emacs

Status: Alpha Rust 1.92+ License: GPL-3.0

Note: Neomacs is in active alpha development. Expect rough edges, breaking changes, and missing features. Contributions and bug reports are very welcome!

Fork notice: Neomacs is a hard fork of GNU Emacs, forked from commit 705c0e3729. The changes are too invasive to ever be accepted upstream, so we did not preserve the original git history to keep the repository lightweight. If you need the full Emacs git history for reference, open an issue and we can re-add it.

Why a fork, not from scratch? Neomacs aims for 100% compatibility with official GNU Emacs — every config, package, and workflow should just work. By forking, we keep the original Emacs C code as a reference and test oracle: we can verify that each Rust rewrite produces identical behavior, ensuring nothing breaks as subsystems are replaced one by one.

Emacs is a 40-year-old C codebase that hasn't kept up with modern hardware or software engineering:

• Display engine — ~50,000 lines of C in xdisp.c, designed for text terminals in the 1980s. CPU-only rendering, no GPU acceleration, no native video/animations, no smooth visual effects
  • Large images — rendering slows down significantly
  • Video playback — not natively supported
  • Modern animations — no smooth cursor movement, buffer transitions, or visual effects
  • Web content — limited browser integration
  • GPU utilization — everything runs on CPU while your GPU sits idle
• Elisp performance — no inline caching, stop-the-world GC, dynamic dispatch overhead. Even with native-comp (AOT), Elisp lacks runtime JIT optimization, speculative inlining, and concurrent GC — leaving significant performance on the table
• Unsafe C codebase — ~300,000 lines of unsafe C with manual memory management, monolithic architecture (runtime and editor entangled), single-threaded design that prevents real concurrency

Throw it all away and start fresh.

Neomacs is rewriting Emacs from the ground up in Rust — starting with the display engine and expanding to the core:

• GPU display engine (done) — ~4,000 lines of Rust replacing ~50,000 lines of legacy C, powered by wgpu (Vulkan/Metal/DX12/OpenGL)
• Rust layout engine (done) — bypasses xdisp.c entirely, reads buffer text via FFI and computes layout in Rust
• Inline video/images/WebKit (done) — 4K video, GPU-decoded images, and WPE WebKit browser views embedded directly in buffers
• 21 scroll effects, 8 cursor modes, 10 buffer transitions (done) — GPU-accelerated animations running on the render thread at display refresh rate
• Zero-copy DMA-BUF (done) — efficient GPU texture sharing (Linux)
• Rewrite entire Emacs core in Rust (in progress) — replacing all ~300,000 lines of C with safe, modern Rust: Elisp runtime, evaluator, bytecode VM, GC, buffer/window/frame subsystems, and all editor internals
• True multi-threaded Elisp (planned) — real concurrency for the Lisp machine, not just cooperative threading
• 10x Elisp performance (planned) — Rust-optimized Lisp machine with JIT compilation and inline caching
• Full Emacs compatibility — your config and packages still work

GPU-decoded directly — no CPU cost, won't block Emacs main thread.

GPU backend, DMA-BUF zero-copy.

GPU-backed terminal emulator embedded in Emacs buffer.

DMA-BUF zero-copy, GPU backend — no CPU cost.

All animations run on the GPU render thread at display refresh rate, independent of Emacs redisplay. Configure everything from Elisp.

8 particle/visual modes (Neovide-inspired):

7 movement styles controlling how the cursor interpolates between positions:

The spring style also supports a 4-corner trail effect where leading corners snap ahead and trailing corners stretch behind, controlled by a trail-size parameter (0.0-1.0).

10 buffer-switch effects triggered when the visible buffer changes:

21 scroll animation effects organized into categories:

5 scroll easing functions:

;; All-in-one configuration:
;; (neomacs-set-animation-config
;; CURSOR-ENABLED CURSOR-SPEED CURSOR-STYLE CURSOR-DURATION
;; CROSSFADE-ENABLED CROSSFADE-DURATION
;; SCROLL-ENABLED SCROLL-DURATION
;; &optional SCROLL-EFFECT SCROLL-EASING TRAIL-SIZE)
;; Example: spring cursor, crossfade buffer switch, page-curl scroll with spring easing
(neomacs-set-animation-config t 15.0 'spring 150 t 200 t 150 7 2 0.7)
;; Example: fast linear cursor, no crossfade, wobbly scroll
(neomacs-set-animation-config t 20.0 'linear 100 nil 200 t 200 10 0 0.0)

Neomacs aims to be the most capable and beautiful Emacs ever built, rewriting its internals in Rust:

• Rich media — 4K video, PDF rendering, image manipulation directly in buffers
• GPU-native — hardware-accelerated rendering, shader effects, 120fps animations
• GPU terminal — Rust-based terminal emulator replacing slow term.el/ansi-term/vterm
• Cross-platform — Linux (Vulkan), macOS (Metal), Windows (Vulkan/DX12)
• Rust core — rewrite Emacs C internals in Rust for memory safety and performance
• Multi-threaded Elisp — true concurrency for the Lisp machine, enabling parallel Elisp execution
• 10x faster Elisp — Rust-optimized Lisp interpreter/compiler to dramatically speed up Elisp

The goal: Make Emacs as powerful and beautiful as it deserves to be.

Neomacs is rewriting Emacs from C to Rust with clean module boundaries. The goal is a layered architecture where the Elisp runtime is a self-contained core, editor subsystems are independent modules communicating through defined APIs, and the rendering engine runs on a separate GPU thread.

The rendering engine and layout engine are already in Rust. The Emacs C core still runs the Elisp evaluator, GC, and editor subsystems — connected to Rust via FFI channels.

┌─────────────────────────────────────────────────────────────────┐
│ Neomacs (Rust) │
│ │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ Elisp Runtime Core │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │ Evaluator │ │ Bytecode VM │ │ GC/Allocator│ │ │
│ │ └─────────────┘ └─────────────┘ └─────────────┘ │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │ LispObject │ │Symbol Table │ │ Type System │ │ │
│ │ └─────────────┘ └─────────────┘ └─────────────┘ │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ Runtime API │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │register_type│ │register_root│ │define_func │ │ │
│ │ └─────────────┘ └─────────────┘ └─────────────┘ │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │ run_hook │ │ specbind │ │signal_error │ │ │
│ │ └─────────────┘ └─────────────┘ └─────────────┘ │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌───────────────────────────────────────────────────────────┐ │
│ │ Editor Modules │ │
│ │ ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐ ┌───────┐│ │
│ │ │ Buffer │ │ Window │ │ Frame │ │Keyboard│ │Process││ │
│ │ └────────┘ └────────┘ └────────┘ └────────┘ └───────┘│ │
│ │ ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐ ┌───────┐│ │
│ │ │ Font │ │ Image │ │File IO │ │ Reader │ │ Data ││ │
│ │ └────────┘ └────────┘ └────────┘ └────────┘ └───────┘│ │
│ └───────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌───────────────────────────────────────────────────────────┐ │
│ │ Rendering Engine │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │Layout Engine│ │wgpu Renderer│ │ Animations │ │ │
│ │ └─────────────┘ └─────────────┘ └─────────────┘ │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │ winit │ │ WebKit │ │ GStreamer │ │ │
│ │ └─────────────┘ └─────────────┘ └─────────────┘ │ │
│ └───────────────────────────────────────────────────────────┘ │
│ │
│ ┌───────────────────────────────────────────────────────────┐ │
│ │ Threading │ │
│ │ ┌────────────┐ ┌────────────┐ │ │
│ │ │EmacsThread │ │RenderThread│ │ │
│ │ └────────────┘ └────────────┘ │ │
│ │ │ ▲さんかく │ │
│ │ ├── FrameGlyphBuffer (crossbeam) ──────┘ │ │
│ │ └── InputEvent (crossbeam) ────────────────────┐ │ │
│ │ │ │ │
│ └───────────────────────────────────────────────────────────┘ │
│ │
│ ┌───────────────────────────────────────────────────────────┐ │
│ │ Backends │ │
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
│ │ │ Vulkan │ │ Metal │ │ DX12/GL │ │ │
│ │ └──────────┘ └──────────┘ └──────────┘ │ │
│ └───────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────┘

Design principles:

• Elisp Runtime Core is a self-contained Rust crate. It owns LispObject, the evaluator, bytecode VM, GC, specpdl, and symbol table. It does NOT know about buffers, windows, frames, or any editor concept.
• Runtime API is a trait-based interface. Editor modules register their types (with GC trace descriptors), roots, and primitives. The GC traces registered types generically — no hardcoded mark_kboards() or mark_terminals().
• Editor Modules are independent. Each owns its data structures and exposes them to Lisp through the Runtime API. Modules do not reach into each other's internals.
• Rendering Engine runs on a separate GPU thread, communicating via crossbeam channels (FrameGlyphBuffer down, InputEvent up). Already implemented.

• Memory safety without garbage collection
• Zero-cost abstractions for high-performance rendering
• Excellent FFI with C (Emacs core)
• Modern tooling (Cargo, async, traits)
• Growing ecosystem for graphics (wgpu, winit, cosmic-text)

• Cross-platform — single API for Vulkan, Metal, DX12, and OpenGL
• Safe Rust API — no unsafe Vulkan/Metal code in application
• WebGPU standard — future-proof API design
• Active development — used by Firefox, Bevy, and many others

For an in-depth analysis of the current Emacs C architecture, why it's hard to rewrite, and why Elisp is slow, see docs/elisp-core-analysis.md.

• Emacs source (this is a fork)
• Rust (stable, 1.92+)
• GStreamer (for video playback)
• VA-API (optional, for hardware video decode on Linux)

# Install dependencies
sudo pacman -S --needed \
 base-devel autoconf automake texinfo clang git pkg-config \
 gtk4 glib2 cairo \
 gstreamer gst-plugins-base gst-plugins-good gst-plugins-bad \
 wpewebkit wpebackend-fdo \
 wayland wayland-protocols \
 mesa libva \
 libjpeg-turbo libtiff giflib libpng librsvg libwebp \
 ncurses gnutls libxml2 sqlite jansson tree-sitter \
 gmp acl libxpm \
 libgccjit
# Install Rust (if not already installed)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
# Build the Rust display engine
cargo build --release --manifest-path rust/neomacs-display/Cargo.toml
# Build Emacs
./autogen.sh
./configure --with-neomacs --with-neovm-core-backend=emacs-c
make -j$(nproc)

Note: WPE WebKit (wpewebkit) is required for browser embedding. It is available in Arch Linux repos and via NixOS. On distros without WPE WebKit packages, the build will skip webkit support and build the Rust crate with --no-default-features --features "winit-backend,video".

docker build -t neomacs-build-test .

Uses Arch Linux. See the Dockerfile for the full build environment.

Neomacs uses nix-wpe-webkit for the WPE WebKit dependency. Pre-built binaries are available via Cachix (~60MB download instead of ~1 hour build).

The flake.nix includes nixConfig for the Cachix cache. Pass --accept-flake-config to use it automatically, or configure it system-wide:

NixOS — add to your configuration (e.g., /etc/nixos/configuration.nix):

{
 nix.settings.substituters = [ "https://nix-wpe-webkit.cachix.org" ];
 nix.settings.trusted-public-keys = [ "nix-wpe-webkit.cachix.org-1:ItCjHkz1Y5QcwqI9cTGNWHzcox4EqcXqKvOygxpwYHE=" ];
}

Non-NixOS — add to ~/.config/nix/nix.conf:

extra-substituters = https://nix-wpe-webkit.cachix.org
extra-trusted-public-keys = nix-wpe-webkit.cachix.org-1:ItCjHkz1Y5QcwqI9cTGNWHzcox4EqcXqKvOygxpwYHE=

Option 1 — Trust the nixConfig in flake.nix (simplest):

nix build --accept-flake-config
# Or enter development shell
nix develop --accept-flake-config

Option 2 — Pass Cachix flags directly:

nix build \
 --extra-substituters "https://nix-wpe-webkit.cachix.org" \
 --extra-trusted-public-keys "nix-wpe-webkit.cachix.org-1:ItCjHkz1Y5QcwqI9cTGNWHzcox4EqcXqKvOygxpwYHE="

Note: Both options require your user to be in trusted-users in /etc/nix/nix.conf (e.g., trusted-users = root @wheel your-username), or configure the cache system-wide as shown above.

Legacy (non-flake users):

nix-shell

cargo build --release --manifest-path rust/neomacs-display/Cargo.toml
./autogen.sh
./configure --with-neomacs --with-neovm-core-backend=emacs-c
make -j$(nproc)

Use --with-neovm-core-backend= to select which core backend gets compiled:

• emacs-c (default): current stable path, uses Emacs C core.
• rust: enables the Rust-core compile-time mode for NeoVM integration work.

We are rewriting the Emacs display engine entirely in Rust. The current system extracts glyphs from Emacs's C glyph matrices and sends them to the GPU — the next step is replacing the C layout engine (xdisp.c, dispnew.c, ~40k LOC) with a Rust layout engine that reads buffer data directly and produces GPU-ready glyph batches. One layout engine, two renderers: wgpu (GPU) and TUI (terminal).

See docs/rust-display-engine.md for the full design document.

Total: ~17-18k LOC Rust replacing ~40k LOC C — fewer lines because we skip terminal/X11/GTK backend code, skip incremental matrix diffing (GPU redraws everything), and leverage modern Rust crates (cosmic-text, unicode-bidi) for the hard Unicode/shaping problems.

Contributions welcome! Areas where help is needed:

• Graphics programmers — shader effects, rendering optimizations
• Rust developers — architecture, performance, safety
• Emacs hackers — Lisp API design, integration testing
• Documentation — tutorials, API docs, examples

Built with:

• wgpu — Cross-platform GPU rendering (Vulkan/Metal/DX12/GL)
• winit — Cross-platform window management
• cosmic-text — Pure Rust text shaping
• GStreamer — Video playback with VA-API
• ash — Vulkan bindings for DMA-BUF import
• Inspired by Neovide cursor animations

GNU General Public License v3.0 (same as Emacs)