[0.10.0] - 2026-08-03

Added

Per-project settings you can commit — a project can carry .editora/settings.toml saying which language server to run and whether to run it, overriding your global preferences for anyone who opens that project. The case it’s for: one repository needs a JDK 17 server and another a JDK 25 one, and you no longer have to remember to flip a global preference between them. Project: Edit Project Settings… creates the file with a commented example. Only toolchain settings can be overridden — appearance, keymap and fonts stay personal, because checking out a repository shouldn’t rearrange somebody’s editor.
New Project From Template — scaffold a whole project and open it in its own window, rather than pointing Editora at a folder you made yourself. Pick a multi-file template, fill in its variables, choose where it goes, and the new folder is registered as a project and opened. Ships with a Python Project template (package layout, a test, pyproject.toml, README and .gitignore); your own multi-file templates appear in the same picker.
Long-running work now says it’s running — a find-in-files sweep over a big tree used to announce itself once and then go quiet, which looks identical to a hang. The status bar now shows what’s in progress with a spinner, and a count when several things run at once; it disappears entirely when nothing is happening.
Failures no longer slip past you — the status bar shows one message at a time and the next one replaces it, so an error that appeared while you were typing used to vanish without trace. Errors are now shown in red, recorded as errors in the message log, and leave a small count beside the status line that stays until you open the log. Warnings are marked too, without the count.
Rename now shows you what it will change — a rename that reaches beyond the current file lists every affected file first, with its change count and where it moves to, and you can untick any file before applying. A rename confined to the file you’re looking at applies straight away as before: it’s on screen and one undo away, so there’d be nothing to confirm.
Run configurations gain a before-launch step, and can be shared with your team — a configuration can name a command to run first (a build, a codegen step); a non-zero exit aborts the launch, so a stale binary is never run by accident. And Export Configurations to Project writes them to .editora/run-configurations.json inside the project, where they can be committed; Import merges them back by name, so importing twice doesn’t duplicate and a colleague’s edit updates rather than doubles.
A run-configuration selector in the toolbar — pick a saved configuration and hit Run or Debug, with Stop beside them; the choice is remembered across restarts. Each configuration also becomes a real command, so it appears in the command palette by name and can be given its own keyboard shortcut, the same way saved macros and external tools already work.
A menu bar — File / Edit / Find / View / Navigate / Code / Run / VCS / Tools / Window / Help, so the things Editora can do are browsable rather than only findable by name in the command palette. Each entry shows its current keybinding and updates when you switch keymaps; a command whose feature is switched off appears greyed rather than vanishing, so the menu stays a stable map. On macOS it sits in the system menu bar. Hide it from Settings → Interface or the palette (View: Toggle Menu Bar); it is hidden automatically in Zen, Expert and Simple modes. The palette is still the complete index — the menu is a curated subset of the ~470 commands.
Two files on screen at once — the editor area can now be split into independent editor groups, each with its own tabs and its own selection, so you can put a header beside its implementation or a test beside what it tests. Split Editor Group Right and Split Editor Group Down move the current file into a new group, Move File to Next Editor Group shifts it along, Focus Next Editor Group moves the keyboard between them, and Merge Editor Groups puts everything back. Closing the last file in a group collapses it, so you never end up staring at an empty pane. All five are in the command palette and bindable. Splits nest, so a side-by-side pair can hold a stacked pair and you can build an L-shaped layout — while splitting the same direction twice widens the existing row instead, giving you three columns rather than a lopsided chain. Drag a tab onto another group to move it there, or onto a group’s edge to split that group and drop the file on that side — a translucent highlight shows where it will land. Your split layout is saved with the session, so the arrangement you left comes back on the next launch (a file that has since disappeared no longer leaves a blank pane behind). This is distinct from the existing Split Editor commands, which show two views of the same file — those still work exactly as before, and the two can be combined.
The Git and GitHub command lines you run are now visible — the shared output console gained a Git and a GitHub tab holding a transcript of the git / gh commands Editora ran on your behalf: the command, its output, and its exit code and duration. Git logs the commands you asked for (commit, push, pull, checkout, stash, clone…) and deliberately not the status/diff reads it re-runs on every tab switch, which would bury them. Neither steals focus: the transcript is waiting when you open the window.
Bracket-pair colorization — each (), [] and {} is tinted by how deeply it is nested, so “how far in am I?” is readable without counting. It is a different question from the existing matching-bracket highlight, which answers “where does this one close?”, and the two combine on the same character. Brackets inside strings and comments are skipped — a stray { in a string would otherwise shift the colour of every bracket below it and read as the feature being broken. On by default, as in VS Code; Settings → Editor turns it off.
Folding gained the four things it was missing — fold a selection into a range of your own choosing (which survives your edits and comes back on the next launch), fold all block comments, fold all #region markers (//#region, #region, #pragma region,  and friends), and fold everything except the block you are in. All four are palette commands and bindable, and they merge with the folds Editora detects — or the ones your language server reports — rather than replacing them.
Pasted Java code imports itself. Paste a snippet into a Java file and the Java language server is asked which imports it needs; they are added for you. This is the one paste behaviour nothing else in the stack can approximate, because it needs the type resolver. An answer that lost a race with your typing is dropped rather than applied to text it wasn’t computed for.
Smart semicolon placement for Java — typing ; part-way through an expression puts it at the end of the statement: compute(1, 2|) becomes compute(1, 2);|. The semicolon is never held back waiting for the server, so typing never stalls; it lands where you typed it and moves afterwards if the server disagrees, as a single undo step. Type straight on through and the correction is skipped rather than applied late.
The GitHub tool window is filterable and keyboard-driven — Pull Requests, Issues and Runs share one filter box that matches on everything a row shows (number, title, author, branch, state, labels), with a leading # optional so 42 and #42 both find PR 42. The window opens with focus in the filter and the first row selected; C-n/C-p move the selection without leaving the box, Down enters the list, Enter opens. The filter clears when you switch segment and survives a refresh.

Changed

Editora has its own look. The palette comes from the app’s own icon — a teal accent, an ink-navy ground and a periwinkle reserved for one job: the keyboard. Editora Light and Editora Dark ship as a matched pair and are the theme a fresh install starts in. Nothing changes for an existing install — your saved theme is kept, and the new pair is simply two more entries in Settings → Appearance alongside Primer, Nord, Dracula and the community themes.
One vocabulary for state, everywhere. Amber now means “not saved yet” in every place it can appear — the tab, the Switcher, the file tree, pickers — and it follows the theme instead of being one fixed ochre that suited a light background and little else. Red is broken, green is verified, olive and violet are git’s untracked and renamed, and periwinkle is only ever a keybinding.
The interface is set in Inter. Editora already bundled it for the Markdown preview and PDF export; now the whole interface uses it, on every platform, instead of whatever default font each system supplied.
Settings has been rebuilt. Every page reads the same way: one background, with each group of settings on a card, and every setting stated as a name, a plain-English line saying what it does, and its control on the right — instead of a stack of bare checkboxes whose labels had to carry the whole explanation. A tool’s detection result is a green or red pill on its own row, and a setting whose feature has a keybinding shows that chord beside its switch, so Settings teaches the keyboard instead of hiding it.
Less line, more space. Editora used to draw a hairline at nearly every seam, and in several places two at once — a panel’s frame plus the frame the tree inside it drew for itself. Those are gone; surfaces are told apart by their shade and their spacing. Menus, tab strips and toolbars are tighter, tabs are shorter, and the rounded corners are consistent from the command palette down to a spinner in Settings.
Menu keybindings line up. Each menu’s shortcuts share one column instead of trailing after their labels at whatever width each one happened to be, so a menu can be read down its right edge. (On macOS, where the menu bar belongs to the system, they stay beside the label — the native menu draws text only.)
Language, Tab Size and Line Endings open a picker, not a dialog. Clicking those status-bar segments used to open a separate window with a dropdown; they now use the same in-scene picker as everything else, which you can type into. The language list is around a hundred grammars, and it was not searchable before.
Projects are on by default. The feature shipped opt-in, behind a checkbox most people never found — and much of what Editora has grown since is anchored to a project: the file tree, per-project bookmarks and notes, find-in-files scope, run configurations, per-project settings. Existing installs are switched on when their settings are upgraded, including installs that had turned it off, since a saved setting cannot say which of the two it was. Settings → Workspace turns it back off.
The run-configuration toolbar group only appears where it applies — the selector and its Run / Debug / Stop buttons used to sit on every toolbar, so a project of Markdown notes carried a dropdown that could never fill. They now show when you are somewhere you could actually launch: with a project open, a Maven, Gradle, npm, Cargo or Go build file inside it or a makefile at its root — a sibling checkout’s build file from a directory above no longer counts. With no project open, any detected build does. Anything you have already saved keeps the group visible regardless: a run configuration only needs a main method, so a plain Java folder can hold one, and hiding the only UI that reaches it would be worse than the empty dropdown. The palette commands are unchanged and still work anywhere.
Quick fixes now appear at the caret — the code-action list used to open as a card centred near the top of the window, the same surface used for picking a project. It now drops just below the cursor, where you are actually looking, with the server’s preferred fix preselected so Enter usually does the right thing. Arrow keys or C-n/C-p move, Enter applies, Escape or C-g dismisses, and the caret stays visible on the spot the fix will land.
Run configurations are no longer Java-only, and no longer care which tab is in front — a saved configuration can now launch a Python script, a shell script or a make target as well as a Java main class, chosen with a Type field in Settings → Run Configurations. Script configurations need no project and no language server at all. Separately, running a saved configuration used to refuse unless a Java file happened to be the active tab — so saving one for your app and then opening a README broke it. Any open Java file in the project now serves, and it only complains when there genuinely isn’t one. Debugging remains Java-only, and now says so instead of reporting a confusing Java error.
The “Build Output” tool window is now just “Output” — it holds build tools, Git, GitHub and CI logs, so the old name undersold it. Your stripe placement and any keybinding are unaffected (only the label changed).
Running an incomplete run configuration takes you to it. It used to say which configuration was missing its main class (or its script) and leave you to go and find it. Pressing Run is a request to run it, so it now opens that configuration’s form with the field you need to fill in — the same thing the toolbar dropdown’s new Edit Configurations… does, from the other direction.
Edit a run configuration from the toolbar dropdown. The dropdown now ends with Edit Configurations…, which opens Settings on the Run Configurations page with the configuration you had selected already picked out — so changing the thing you just chose no longer means navigating there and finding it again. It is offered even with nothing saved, which is one way to create your first. Also available from the palette as Run: Edit Run Configurations….
Adding a run configuration starts from the file you are looking at. Settings → Run Configurations → Add used to create a wholly blank entry called “New Configuration”. It now prefills the main class from the active Java file (or the one your Gradle build declares), names the configuration after that class, and puts the cursor in the field that still needs you — the main class when there was nothing to suggest, the name otherwise. Adding twice from the same file gets you “App” and “App (2)” rather than two entries with the same name, which previously collided into a single palette command.

Performance

Closing a large tab no longer stalls highlighting everywhere else. Files of the same language share one grammar, and only one of them can be tokenized at a time, so a background pass over a very large document held that lock for its whole duration and every other file of that language waited behind it. Two paths let such a pass run when nothing needed it any more: a pass that had already been superseded ran to completion instead of stopping, and a closed buffer could still dispatch a fresh one. Both are now refused.

Fixed

A run configuration with no main class now says so, instead of reporting a Java language server stack trace. Adding a configuration in Settings creates an empty one, and running it before filling in the main class sent an empty search to the language server, which answered with an internal SearchPattern … is null error. It now tells you which configuration is missing its main class — the same thing the script configurations have always done about a missing script.
A stray command-line flag no longer opens its value as a file. Any two-token option Editora doesn’t define — a JVM flag leaking into the program arguments, say — had its value treated as a path, so launching could greet you with Failed to open: <cwd>/javafx.graphics/com.sun.glass.ui=com.editora. A token sitting directly after an unrecognized option is now only opened if it actually exists on disk; editora typo.txt still reports the typo as before.
Doctor no longer crushes the tool name. A row is laid out as one line, so a long resolved path shrank everything beside it and the name identifying the row was reduced to ”…” or “Docker…”. The name now keeps its width and only the paths shrink — ellipsized from the left, since the binary at the end is the informative part, with the full text on hover. The column also grows with the window and follows the text zoom.
The Split Vertical and Split Horizontal buttons are disabled where they would do nothing. The Welcome and Doctor pages and the image, hex, PDF and diff viewers aren’t text buffers and can’t be split, but the buttons stayed lit and silently did nothing when pressed.