eval-exec/neomacs

---

eval-exec/neomacs.json

{
  "createdAt": "2026-02-03T08:45:40Z",
  "defaultBranch": "main",
  "description": "NEO Emacs (WIP): GPU powered Emacs written in Rust with a modern display engine. Aiming for modern design & multi-threaded Elisp, 10x performance, zero-pause concurrent GC and 100% Emacs compatibility.",
  "fullName": "eval-exec/neomacs",
  "homepage": "https://neomacs.org",
  "language": "Rust",
  "name": "neomacs",
  "pushedAt": "2026-08-03T00:15:16Z",
  "stargazersCount": 1044,
  "topics": [
    "editor",
    "elisp",
    "emacs",
    "lambda",
    "lisp",
    "neomacs",
    "neovim",
    "productivity",
    "rust",
    "terminal",
    "vim",
    "wgpu",
    "winit"
  ],
  "updatedAt": "2026-08-03T00:15:23Z",
  "url": "https://github.com/eval-exec/neomacs"
}

“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?]!(docs/faq.md))

[!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]!(docs/faq.md).

Showcase

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

https://github.com/user-attachments/assets/85b7ee7b-3f4a-4cd2-a84f-86a91d052f11

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

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

https://github.com/user-attachments/assets/275c6d9a-fced-44f6-8f43-3bbd2984d672

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]!(docs/animations.md))
• 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]!(#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]!(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]!(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)