mrkeyoor.com_
Sun 20 Sept 17:48 UTC
Dev Toolsevaluationupdated 20 Sept 2026

neomacs review

NEO Emacs is a work-in-progress hard fork of GNU Emacs that replaces the C core with Rust and draws its interface through a GPU renderer. It keeps the Emacs Lisp tree so existing configurations and packages can run while the project experiments with richer media, animation, and new runtime internals.

Verdict

Our NEO Emacs build and test commands each hit the 900-second cap, and the test log recorded a startup binding failure before time ran out. That makes v0.0.18 an ambitious second editor for Emacs enthusiasts, not a safe replacement for a working setup. Try a prebuilt package if the GPU renderer interests you, but keep GNU Emacs available and expect to file compatibility bugs.

We ran it

Lab card: what happened when we ran neomacsScreenshot of neomacs (neomacs.org)
Install✓ · 47s697 packages
Build✗ timed out · 900s
Tests✗ timed out · 900sran, no count parsed
Repo12117 files~2,960,100 lines of source · 265.2 MB · 20 CI workflows · tests dir

Answers from our run

Does neomacs build from source?

Dependencies installed in 47 seconds (697 packages), and the build failed. We cloned commit 83c5895 into a clean Debian container with 3 CPUs and no project-specific setup.

Do neomacs's tests pass?

We could not finish them: the suite was still running after 15 minutes in our container.

Who should not use neomacs?

Anyone who needs a stable daily editor: the README calls NEO Emacs a work in progress with breaking changes and missing features.

What are the alternatives to neomacs?

GNU Emacs, Neovide, Helix. Our NEO Emacs build and test commands each hit the 900-second cap, and the test log recorded a startup binding failure before time ran out.

Setup2/5Prebuilt packages help; source build exceeded 900 seconds
Docs5/5Detailed build, architecture, platform, and parity guidance
Community4/5Daily pushes, active triage, and frequent early releases
Maturity1/5Alpha compatibility work with experimental desktop ports

Who it’s for

Emacs users who want to test a Rust core without giving up their Lisp configuration.
Rust and editor-runtime contributors interested in evaluators, garbage collection, layout, and GPU rendering.
Linux users with supported graphics hardware who can keep GNU Emacs installed as a fallback.
Package authors willing to report behavioral differences against the pinned GNU Emacs reference.

Who it’s NOT for

Anyone who needs a stable daily editor: the README calls NEO Emacs a work in progress with breaking changes and missing features.
Developers expecting verified drop-in compatibility today: the project estimates about 95 percent, and our timed-out test run recorded a startup parity failure.
Low-spec or GPU-less systems: issue 109 reports no suitable GPU adapter, while issue 402 asks for a CPU fallback.
Windows or macOS teams seeking settled platform support: both are labeled experimental, and the README says Windows awaits testing.
Contributors needing quick source builds: both build and test commands exceeded our 900-second limits.

Setup reality

Our sandbox installed 697 packages in 47 seconds. The build did not finish within 900 seconds, and the test command also timed out at 900 seconds. Before the test cap, the log marked startup::tests::gnu_startup_restores_meta_and_ctl_x_bindings as failed.

Prebuilt v0.0.18 packages need no account or service credential. Source work uses a pinned stable Rust toolchain, with Nix offered as the easiest dependency shell. GStreamer enables video, WPE WebKit enables the Linux browser, and a matching GNU Emacs build acts as the local parity reference.

The checkout is unusually large: 12,117 files, about 2.96 million source lines, and 265.2 MB before build output. macOS and Windows are experimental. Linux media support still depends on host codec plugins, while GPU availability and driver support affect whether the graphical editor starts.

A 2.96-million-line tree preserves Emacs Lisp over a Rust core

NEO Emacs is a hard fork, not a new editor borrowing Emacs keybindings. The project retains the Lisp side of GNU Emacs and replaces the C core with Rust implementations of the evaluator, bytecode machine, garbage collector, buffers, windows, processes, layout, and rendering. That choice explains the size of our checkout: about 2.96 million source lines across 12,117 files. Much of the familiar ecosystem remains present because compatibility depends on running the same Lisp, not imitating its surface.

The visible change is a wgpu display engine. The README describes GPU text and images, inline video, an embedded browser, a terminal buffer, shaders, and configurable cursor or buffer animations. The same binary also has a terminal mode. These features make NEO Emacs more than a language-runtime exercise, but they do not settle the editor question. An Emacs replacement succeeds when a user's existing config behaves correctly for months, not when a demo renders a 4K clip.

The README's 95 percent compatibility estimate still leaves daily gaps

The status table estimates GNU Emacs compatibility at about 95 percent and labels the editor a work in progress. GNU Emacs acts as the test oracle: parity suites compare behavior, terminal grids, and graphical results against a pinned upstream version. This is the right standard for a hard fork because a package can load successfully and still draw the wrong mode line, bind a different key, or change subtle Lisp behavior. The project's own warning about missing features should carry more weight than the percentage.

Compatibility also creates a moving target. Issue 271 tracks synchronization with GNU Emacs and records an Emacs 31.1 Lisp baseline while upstream master has moved further. The issue calls for oracle-gated sync work rather than copying files blindly. Issue 177 shows the user-facing side of the problem: an older font configuration produces different Chinese font rendering than Emacs. NEO Emacs can preserve an init.el and still diverge in the behavior that configuration was written to control.

What happened when we ran it

Our measurement setup used commit 83c5895 in a 3-CPU, 12 GB Rust sandbox. Installing 697 packages succeeded in 47 seconds. The checkout occupied 265.2 MB before build output. A release build then ran for 900 seconds without finishing, so we cannot claim a successful compile or state how much longer it needed.

The test command also reached the 900-second cap. Before timeout, the log showed Lisp language files loading and marked startup::tests::gnu_startup_restores_meta_and_ctl_x_bindings as failed. It continued printing load paths and dump-mode messages, which means the process had not reached a final suite summary. The log does not establish the cause of that failure. Our run proves that this checkout was expensive to verify in the stated sandbox and did not produce a clean result within 15 minutes.

Version 0.0.18 is much easier to download than to compile

Release v0.0.18, published September 11, provides Linux archives, AppImages, Debian and RPM packages, Apple Silicon macOS bundles, Windows installers, and container images. Checksums accompany the assets. That distribution work changes the practical recommendation: a curious user should start with a prebuilt package, while source compilation is better left to contributors who need the current tree or an unsupported setup. The packaged route avoids our 900-second build problem, though it does not remove runtime compatibility gaps.

Source builders have several platform branches to understand. The pinned Rust toolchain is only the start. GStreamer enables video, WPE WebKit supplies the Linux inline browser, and VA-API can provide hardware decoding. The Fedora and RHEL guide says their repositories do not supply the WPE WebKit dependency, so that browser feature needs external source or packages. Tests also expect a specific GNU Emacs reference on PATH, since a newer upstream can change shared Lisp output and create widespread comparison failures.

GPU rendering creates a hardware floor that GNU Emacs does not have

Issue 109 reports startup failing because no suitable GPU adapter was found on one Linux system. Issue 402 asks for a fallback on weak or absent graphics hardware after trouble under WSL. Windows issue 384 describes severe lag while selecting text with the mouse on v0.0.18. None of these reports proves that every machine on those platforms will fail. Together with the project's experimental platform labels, they show why hardware and driver testing belongs near the start of an evaluation.

The renderer also expands what compatibility means. Fonts, cursor placement, overlays, input routing, web views, codecs, and window systems all become part of the promise. Release v0.0.18 includes fixes for layout, font metrics, macOS Option chords, terminal linking, and inverse video. Those are signs of active engineering, and also a list of surfaces where a daily editor can feel wrong long before it crashes.

Twenty CI workflows show activity, while the 900-second caps show cost

GitHub recorded the last push on September 20 and listed 53 combined issues and pull requests. Our checkout contained 20 CI workflow files and a tests directory. Release v0.0.18 arrived 9 days before that push, and current issues were receiving maintainer responses. This is an active alpha rather than an abandoned experiment. The pace is useful for contributors, but it also means behavior can change quickly between a tagged package and main.

Use NEO Emacs beside GNU Emacs, with a copy of your configuration and a clear rollback path. Its Rust core and GPU frontend are substantial work, and the project documents its unfinished areas unusually well. The two 900-second timeouts are the decision point: this is a project to test and help shape, not an editor to make responsible for your whole working day yet.

Alternatives

ProjectWhat it isPick it when
GNU EmacsThe established Emacs implementation and the compatibility reference NEO Emacs follows.pick this instead when package compatibility and predictable daily use matter more than a Rust core or GPU effects.
NeovideA GPU-accelerated graphical frontend for Neovim.pick this instead when smooth GPU rendering matters and you are comfortable using the Neovim ecosystem.
Helix gh↗A Rust terminal editor with built-in language tooling and modal editing.pick this instead when you want a Rust-native editor without carrying an Emacs configuration forward.

What people are saying

  1. [github-trending] eval-exec/neomacs

Sources

  1. NEO Emacs repository and README
  2. NEO Emacs v0.0.18 release
  3. NEO Emacs source build guide
  4. NEO Emacs fork and compatibility FAQ
  5. GPU adapter failure report
  6. GNU Emacs synchronization tracker

More dev tools reviews

smolvm · pingora · wx-cli · modern-software-dev-assignments · skills · Apktool · the whole board →