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
| Editor | Median | Range |
|---|---|---|
| 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
| Editor | Median | Range |
|---|---|---|
| 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
| Editora | VS 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
- You want a specific extension. Editora's plugin registry is small, and VS Code almost certainly has what you are looking for.
- You do heavy Java or Kotlin refactoring. IntelliJ's static analysis and refactoring tools go well beyond what a language server exposes.
- You already have a tuned Emacs configuration. Editora borrows the editing model, not the extensibility; nothing here replaces Elisp.
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.