"I started Neomacs because I love Emacs, I respect Emacs, and I want to evolve the legendary Emacs into the ultimate modern powerhouse." — Eval Exec

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

Emacs, rewritten in Rust — unleashed on the GPU, fixing what 40 years of C never could.
Built for 100% compatibility with the Emacs ecosystem you already have — your config, your packages, your muscle memory.

Install · Showcase · Animations · Architecture · FAQ · Discussions

NEO Emacs keeps everything that makes Emacs Emacs — your init.el, your packages, your muscle memory — and rebuilds the machinery underneath: the display engine runs on the GPU, and the ~300,000-line C core is reimplemented in Rust. GNU Emacs itself serves as the test oracle, so every rewritten subsystem is verified to behave identically. (Why rewrite Emacs?)

Important

NEO Emacs is a work in progress. Expect rough edges, breaking changes, and missing features — bug reports are very welcome.

Note

NEO Emacs is a hard fork of GNU Emacs (Lisp tree synced to emacs-31.0.90). The C core has been fully replaced by Rust. Fork provenance and rationale: FAQ.

Showcase

Cursor, buffer-switch, and scroll animations — GPU-rendered at display refresh rate:

2026-02-07_16-49-54.mp4

More: 4K video, inline browser, inline terminal, rounded box faces…

Inline 4K Video Playback — DMA-BUF zero-copy, GPU backend

2026-02-07_16-36-47.mp4

Inline 4K Images — GPU-decoded, won't block the Emacs main thread

Inline Web Browser (WPE WebKit) — GPU backend, DMA-BUF zero-copy

Inline Terminal (Alacritty) — GPU-backed terminal embedded in a buffer

GPU Text with Rounded Box Faces

Highlights

• GPU display engine — text, images, and effects rendered via wgpu (Vulkan · Metal · DX12 · GL); ~4,000 lines of Rust replace ~50,000 lines of xdisp.c
• Rich media in buffers — inline 4K video (GStreamer + VA-API), GPU-decoded images, a WPE WebKit browser, and a GPU terminal — all zero-copy via DMA-BUF
• Animations everywhere — 8 cursor modes, 21 scroll effects, 10 buffer transitions at display refresh rate, all configurable from Elisp (full catalog)
• Hackable below the Lisp line — in GNU Emacs, hackability ends where the C display engine begins; NEO Emacs opens the whole frontend to Elisp, from render effects down to GPU shaders (WGSL) — hack the pixels, not just the text
• Compatibility as the contract — your init.el, packages, and muscle memory; every rewritten subsystem is diffed against GNU Emacs as a test oracle, and real-world configs like Doom Emacs are the daily test bed
• Pure-Rust core — no C left: the Elisp evaluator, bytecode VM, GC, portable dump, and editor internals are all memory-safe, modern Rust
• GUI or terminal — the same binary renders on the GPU or in a TTY (neomacs -nw)
• What's next — true multi-threaded Elisp and a concurrent zero-pause GC (status)

Install

Download the latest release for your platform from Releases:

Platform	Packages
Linux	AppImage · .deb · .rpm · tarball (x86_64, aarch64)
macOS (experimental)	.dmg (Apple Silicon)
Windows (experimental)	installer .exe · portable .zip

Build from source

git clone https://github.com/eval-exec/neomacs && cd neomacs

# Optional (recommended): repo dev shell with all dependencies
nix develop --accept-flake-config

# Compiles Rust, bootstraps Elisp, generates the portable dump
cargo xtask fresh-build --release

./target/release/neomacs

Platform dependencies (Arch, macOS, Nix/Cachix) and the test suites: docs/building.md.

Status

Area	State
100% GNU Emacs compatibility (oracle test suites)	🚧 ~95%, closing the last gaps
JIT compilation + inline caching for Elisp	🚧 working, profiling and improving
zero pause GC	🚧 maturing
Elisp-hackable frontend — GPU shaders, surfaces	🚧 early, expanding
Rust Elisp runtime — evaluator, bytecode VM, portable dump	🚧 refactoring, testing, improving
GPU display + layout engine (replaces xdisp.c)	🚧 early, improving
Inline images, 4K video, WebKit browser	🚧 works today, experimental, improving
High-performance neo-term (GPU terminal)	🚧 in development
Cursor / scroll / buffer-switch animations	🚧 polishing, catalog growing
Performance	🔬 profiling, benchmarking, tuning
True multi-threaded Elisp	🔬 designing, researching, experimental attempts
TUI renderer (neomacs -nw)	🚧 usable, polishing
Cross-platform support	🚧 Linux & macOS first; Windows awaiting testing; WASM, Android & iOS planned

Architecture

Everything runs in Rust across two threads — the Emacs thread owns the Elisp runtime and editor state, the render thread owns the GPU.

Design principles, the full module map, and why Rust/wgpu: docs/ARCHITECTURE.md.

Sponsoring

NEO Emacs is a long-term project that takes significant ongoing work to build, test, and maintain. If NEO Emacs is useful or exciting to you, please consider supporting its development on ❤️ GitHub Sponsors.

Acknowledgments

Built with wgpu · winit · cosmic-text — cursor animations inspired by Neovide.

License

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