coming from emacs

Rune vs. Emacs.

Emacs invented the ambition every IDE still chases: one environment for everything, malleable all the way down, decades ahead of its time.

Rune

Strengths

Editors, terminals, language tooling, debugging, and agents are integrated on install
Editor, terminal, tooling, and agent workloads run concurrently
A workspace symbol index covers supported languages without language servers or TAGS files, with results streaming as you search
Built-in Emacs editor: point and mark, kill ring, isearch, query-replace, numeric arguments, macros, and M-x, without an init file
Terminals, tasks, and agents share the editor's tiled workspace model
GNU Emacs can stay your editor through exo mode
The IDE, tooling, and agents attach to remote hosts over SSH workspaces

Weaknesses

No live in-process malleability comparable to Elisp
No Org mode or Magit equivalent
The built-in editor covers common Emacs commands, not GNU Emacs's full surface
Exo mode runs terminal Emacs, so GUI-specific behavior does not carry over
Advanced semantic support for selected languages only
Free for personal use; paid for professional or commercial use, available by subscription or perpetual license
No Windows support
Rune is newly released and will have rough edges. Although it has been used internally for years, its broader language support and range of Linux environments have not yet been battle tested by a large user base

Emacs

Strengths

Free of charge and free software, with 40+ years of development and broad platform support, including Windows
Live Elisp introspection and customization throughout the environment
Org mode and Magit provide unusually deep, integrated workflows
A mature package ecosystem with decades of mode-specific functionality
TRAMP, Dired, Calc, and compilation-mode have deep built-in capability
A daemon/client model for persistent buffers, processes, and sessions

Weaknesses

Heavy interactive workloads can make the UI feel unresponsive
Cross-file symbol navigation needs a running language server or a manually regenerated TAGS file
A cohesive IDE usually means assembling and maintaining packages and per-language config, or adopting a distribution
Terminal support is split across built-in buffers and third-party packages
Layered keymap precedence and conflicts are part of maintaining a large config
AI workflows are assembled from community packages rather than shipped integrated

How they compare

	Rune	Emacs
Monorepos	Each language extension discovers projects through its project markers, and a language server starts only when you open a file in that project, rooted at that project and scoped to its subtree. A mixed-language repo gets one scoped server per project instead of every server loading the whole tree. File, text, and structural search stream workspace-wide results and are tuned to handle millions of files, and the rg package plugs ripgrep into file and text search with one `pkg install rg`.	project.el treats the version-control root as the project, so subprojects inside a monorepo need extra root markers before Eglot scopes a server to them; otherwise each language's server roots at the whole repo. lsp-mode publishes a performance-tuning guide for exactly this situation, covering garbage-collection thresholds, process-output size, and file-watcher exclusions. All server traffic is parsed on Emacs's single-threaded event loop, which is where very large repos are felt most.
Symbol searching	Rune keeps a symbol index that finds a function, type, or variable definition anywhere in the workspace for its supported languages, with no language server and no tags file to generate. Indexing streams into an embedded on-disk database, so memory stays flat even on large trees, results stream in as you search, and the same index powers navigation for both you and Rune's agent.	Workspace symbol navigation goes through xref: with Eglot or lsp-mode it uses a running language server, while the etags backend uses a TAGS file you generate with etags or ctags and rebuild as code changes. imenu indexes only the current buffer. So cross-file symbol search needs either a language server or a maintained tags file.
Execution & rendering	Rune uses a native GUI with GPU-backed font rendering on macOS and Linux. Its core is designed to run editor, terminal, language-tooling, and agent workloads concurrently.	Emacs has native GUI and terminal builds, native compilation, asynchronous subprocesses, and threading primitives. Heavy interactive work can still make the UI feel unresponsive, depending on the packages and workloads in use.
Editing model	A built-in Emacs editor: point and mark with a mark ring, region kill and yank backed by a kill ring, incremental search, query-replace, numeric arguments (`C-u`, `M-1`…`M-9`, negative), transpose chars and words, sentence and paragraph motion, case commands, `M-q` fill, zap-to-char, delete-horizontal-space, delete-indentation, keyboard macros, an echo-area minibuffer, and GNU one-undo-per-command semantics. The muscle memory carries over without an init file.	GNU Emacs is still the deepest editing environment there is: composable major and minor modes, registers, narrowing, rectangles, full minibuffer completion, and decades of package-specific behavior, every command written in Elisp and redefinable while it runs.
Keybindings	Ctrl and Alt drive the Emacs editing layer, with Alt as Meta and Command/Super reserved for Rune's window manager so the two layers never collide. M-x opens the command prompt, and the familiar C-x family runs Rune's file, window, search, Git, and language-tooling commands. The editing keymap is not fully rebindable yet.	GNU Emacs composes global, major-mode, minor-mode, transient, and package-specific keymaps through a defined precedence system. That is extremely flexible, but understanding precedence and resolving conflicts can become part of maintaining a large configuration.
Organizing model	Rune is a screen multiplexer at its core: editors, terminals, TUIs, tasks, and agents run as peer tabs in tiled windows across multiple workspaces. Every part of the layout is malleable from the keyboard: split windows, resize or rearrange them, move tabs between windows, or expand one window to fill the workspace.	Everything is a buffer, backed by an unusually deep ecosystem of buffer-native interfaces. Reaching that level of integration for a new tool generally means adopting or writing Emacs Lisp.
Terminal workflows	A native terminal surface is built into Rune's workspace model. Shells, TUIs, tasks, and agents can remain visible beside editors and move through the same tab and window-management commands.	Emacs ships shell and eshell buffers plus term and ansi-term terminal emulation; packages such as vterm and eat add higher-fidelity terminal emulation. Each is an Emacs buffer, with capabilities and tradeoffs that depend on the implementation.
AI & agents	Rune's own agent lets you use your own API key, connect a custom model endpoint, sign in with a ChatGPT or Claude subscription, or run a local model. Claude Code, OpenCode, and other terminal-based agents run natively in terminal tabs, so you can manage them like any other tab and tile multiple sessions across workspaces.	Capable packages such as gptel, ellama, and aidermacs integrate model providers, and terminal agents can run in Emacs buffers. You choose and compose those pieces rather than receiving one supported agent workflow.
Language intelligence	Structural search and syntax highlighting have broad coverage, but semantic tools, debuggers, and symbol indexing are only supported for a curated set.	Eglot, tree-sitter integration, GUD, and GDB support ship with Emacs; Dape and dap-mode add modern DAP workflows. Coverage is broad, while external servers, grammars, adapters, and per-language configuration are generally selected and maintained by the user or a distribution.
Remote development	SSH is a first-class workspace scheme, not a separate remote mode. Open an ssh:// workspace and Rune works as it does locally, while rendering and interaction stay on your machine and remote file I/O runs asynchronously. Rune provisions your local language packages onto the remote by default.	TRAMP makes remote files and processes available to compatible Emacs commands. It brings remote resources into Emacs, while Rune attaches the broader IDE environment to the remote host.
Extensibility	Any CLI or TUI is already a plugin: run it in a tab, bind it to a key, make it a task to re-run when a file changes, or combine it with runectl to observe editor state and manipulate it using the API surface available to SDK extensions. Use Rune's Go, Rust or Python SDKs to build an extension that needs to run for the lifetime of the workspace, registering multiple commands, or add a persistent UI.	Elisp reaches through the running environment: inspect state, advise functions, redefine commands, compose modes, and reshape the editor while it runs. This is Emacs's real superpower, and Rune does not try to match live in-process malleability.
Pricing & ownership	Rune is free for personal, non-commercial use. For professional or commercial use it is a paid, proprietary product, available by subscription or as a perpetual license. A perpetual license includes two years of upgrades, and covered builds remain usable afterward. Model access is separate. See the pricing page for current plans and discounts.	GNU Emacs is free of charge and free software under the GPL. Its source can be inspected, modified, redistributed, forked, or maintained independently of a commercial vendor.
Learning curve	The Emacs preset gives a working editor without an init file. Point and mark, kill ring, isearch, query-replace, numeric arguments, macros, M-x, and the C-x family work out of the box; GNU's full mode and package surface does not.	A stock install is minimal, so productive setups usually grow a config over time: keymap precedence, package choices, and Elisp to maintain. That customizability is also the source of the upkeep.

Should you switch?

Switch to Rune if…

You want point-and-mark editing and familiar Emacs commands in a curated IDE, rather than using Emacs itself as the application runtime. You want C-x C-s, C-w, M-w, C-y, isearch, query-replace, kill ring, keyboard macros, and M-x from the first launch, with terminals, language tooling, debugging, tasks, and agents already wired together.

Stick with Emacs if…

Org mode, Magit, TRAMP, or another deep Emacs-native package is your center of gravity; rewriting the editor live in Elisp is the whole point for you; you run on Windows or depend on the daemon/client model; or free software is non-negotiable. Those are real reasons to stay, and Rune keeps real Emacs one keystroke away for them.

Something missing or incorrect?

Send us a message

This comparison is written by Unstable Build. It reflects public documentation and our product experience, not independent benchmarking. Facts last checked July 2026.