How Editora compares

Editora does not try to replace every editor for every person. This page covers where it differs, where it does not, and what we measured.

Startup, measured

These measurements were taken in October 2026 on Editora 0.22.0. Both tables are the median of timed runs on the one machine below, with every editor fully quit between runs and launched the same way. The clock starts at launch and stops when a window owned by that editor carries the file's or project's name in its title.

Model
14-inch MacBook Pro, M5 generation (Mac17,2)
Chip
Apple M5, 10 cores (4 performance, 6 efficiency)
Memory
16 GB unified
Storage
Apple 1 TB internal SSD (APPLE SSD AP1024Z), 255 GB free
OS
macOS 27.0 (build 26A428)
Displays
AORUS FI32U at 5120×2880 (main, where the windows opened), alongside the built-in 3024×1964 Liquid Retina XDR
Power
AC, battery at 80%

One machine is the point — every figure here is comparable with every other figure here, and with nothing else. A different Mac, a different macOS, a laptop on battery or one driving an external display will all give different numbers.

They replace a set taken in July 2026 with a much coarser harness, and the two sets are not comparable.

Opening a single file

EditorMedianRange
Editora 0.22.0 0.52s 0.51s to 0.53s
VS Code 1.142.0 0.59s 0.57s to 0.59s
IntelliJ IDEA 2026.2.3 2.18s 2.14s to 2.29s

Five runs each, opening a 710-line Markdown file with no project loaded. Editora is ahead of VS Code by 68 ms, and the two spreads do not overlap, so the order is real — but it is a sixteenth of a second, which nobody will feel. What this does not show is the file's text arriving: Editora's own instrumentation puts its window at 475 ms and its first painted frame at 890 ms on this fixture, and VS Code and IntelliJ have a gap of their own that we cannot see from outside.

Opening a project folder

EditorMedianRange
Editora 0.22.0 0.58s 0.55s to 0.61s
VS Code 1.142.0 0.66s 0.65s to 0.66s
IntelliJ IDEA 2026.2.3 3.16s 2.19s to 3.97s

Three runs each, opening a 117 MB source repository of 3,680 files (a clean clone of Editora's own). Treat IntelliJ's figure as the roughest of the six: its three runs came in at 3.97s, 3.16s and 2.19s, a spread far wider than its median is precise. The discarded warm-up runs are a better illustration still — VS Code's was 3.08s against the 0.66s it then settled to, so a cold first open of a project is a different measurement from any of these.

How the measurement works

Each editor is quit, the machine is left to settle, then the app's binary is launched with the file or folder as an argument. A watcher polls the window server every 5 ms until that editor owns an on-screen window whose title names the file or project, and that is the moment recorded. A discarded warm-up run precedes the timed ones, so every editor is measured with a warm page cache.

Waiting for any window would be easier, but it would give the wrong answer. IntelliJ puts up a splash window and then a welcome window titled only IntelliJ IDEA well before its editor exists, and timing either would have understated it by seconds. Matching on the window title is the only definition that means the same thing across an Electron app, a JetBrains IDE, and a JavaFX app.

Each editor needs one flag to open only what is under test and restore nothing else: Editora is given --no-session --new-instance, and the project run also --project, because a bare folder argument leaves its title at plain Editora with no project name to match. VS Code gets -n --disable-workspace-trust. IntelliJ takes no such flag, so the project folder was added to its trusted paths beforehand rather than having a trust dialog block the run.

A window appearing is not the same as the file being readable in it, and this measures the former. For Editora the difference is roughly 400 ms; for the other two it is unmeasurable from outside, so the figures are an early bound for all three rather than a like-for-like account of when you can start reading. Nor are they a cold boot, a measure of when indexing finishes, or a claim about your hardware: they are relaunches on one machine, and all three editors keep working in the background after their window arrives.

Where each one is strong

 EditoraVS Code, IntelliJ, Emacs
Keybindings Five complete keymaps (Emacs, CUA, Sublime, VS Code, IntelliJ), every command rebindable VS Code and IntelliJ can each install the other's keymap as an extension or plugin; Emacs is its own thing entirely
Reaching a command Everything is a registered command with an id, reachable by chord or fuzzy M-x search. No hidden actions Emacs's M-x is where the idea comes from. VS Code's Command Palette and IntelliJ's Find Action are close in spirit
Interface range Four modes in one app, from Zen (bare text) to a full IDE, each a palette command away (Zen and Expert also have a chord in the Emacs keymap) VS Code has a Zen mode, IntelliJ has Zen and Distraction-free modes, and Emacs can be configured down to bare text
Language support 26 language servers, using the ones already installed on your machine VS Code's extension marketplace is far larger. IntelliJ's Java and Kotlin tooling is deeper than anything here
Account and telemetry None. No sign-in, no usage reporting, no subscription VS Code collects telemetry by default (it can be turned off). IntelliJ IDEA's core is free, and its Ultimate features need a paid subscription
Extensibility A plugin API and a signed registry, small by comparison Tens of thousands of extensions for VS Code, a mature plugin market for IntelliJ

When Editora is probably the wrong choice

When it fits

You keep your hands on the keys and want every action to be a command you can find or rebind. You want language servers, a debugger, git, and live previews without an account or a subscription. And you want an editor that can be a bare page for writing and a full IDE for the same project ten seconds later.

Download Editora or read the source.