What's New in 0.24.x

Everything shipped in the 0.24.x release series, straight from the changelog. Each release's announcement, with the highlights, is on News.

[0.24.0] - 2026-10-24

Added

  • An icon for every Settings page. Each category in the Settings window’s sidebar now has a glyph before its name — a palette for Appearance, a pencil for Editor, a padlock for Encryption, and so on — in the UI Kit’s outline style. Pages that already have an icon elsewhere reuse it (Git, GitHub, Terminal, Debugging, Search, Templates), so they look the same in Settings as on the tool stripe and toolbar. The glyph is muted, brightens on hover and takes the accent colour with the selected row; the Beta pill and modified-setting count stay after the name.
  • Narrowing from the Structure panel, and a narrowed editor that says so. The Structure tool window’s sort row gains a Narrow to fold region toggle. One click narrows the editor to the picked symbol’s own block and turns the mode on — while on, a click on another symbol narrows to that one instead — and a second click shows the whole file again. The outline stays the whole file’s while narrowed — rows outside the region are muted, and in the mode a click on one walks the file to it — and the block is found in the whole document, so a narrowed buffer can be re-narrowed to the block around it. Browsing the outline never narrows: the arrow keys, the filter field and a right-click only select. The toggle is disabled for a file that cannot be narrowed, hidden in Simple UI mode, reachable from the keyboard (f while the tree has focus, and the command structure.narrowFold for any keymap), and its tooltip names the keys and that language support pauses while narrowed. It follows the buffer: lit while the panel narrowed it, an amber border while a chord did. A narrowed editor shows it in the text itself, not only in the status bar pill: an amber banner above the code names the accessible lines (“Narrowed to lines 120–180 of 950”) with a Widen button, and the gutter’s line numbers — which now keep the file’s numbering while narrowed instead of restarting at 1 — turn amber. The status bar’s Ln and the Structure rows’ line numbers count from the top of the file too, and the status bar pill reads “Narrowed · Widen”. C-x n d and C-x n f look for their definition and block in the whole document, as Emacs does, rather than in the narrowed region.
  • A Java debugging sample. samples/debug/java/ is a small standalone Java 25 Maven project (six classes, nine green JUnit tests) with a break here comment at every spot worth a breakpoint: plain, conditional, hit count, logpoint, inside a lambda, in a caught and an uncaught exception, on three named worker threads, in a recursive pattern-matching switch, plus set-value on a static field and a method to change under hot code replace. samples/README.md lists each spot.

Changed

  • Settings says which project the Project scope edits. In a project window the scope switch’s Project pill reads “Project: name” (the name the main window’s title shows; the folder path is its tooltip), the scope bar is tinted while Project is selected, the window is titled “Settings — Project: name”, and the note leads with the project the changes apply to and the .editora/settings.json they are saved in.
  • The Project Map always opens in its own window. The Project tool window’s Tree / Map switch is now a single Map button: the tool window keeps showing the tree, and the Map opens in a separate, resizable window beside the editor window (or on another screen), or comes forward when it is open already. The window has its own search field, is not pinned above the editor window — opening a file from the Map brings the editor forward — and closes with its editor window or project. Rename, New Folder and Delete from the Map ask in the Map window. Whether the window was open, and where, is remembered per workspace (schema v24); a workspace that last showed the Map reopens it. project.toggleMapView (Project: Open / Close Project Map Window) opens the window even with the Project tool window closed, and closes it when it is the window in use.
  • Refactor: the rest of the flat com.editora.editor package split into feature sub-packages. After editor.debug and editor.http, the editor’s presentation code moves next to the core package it presents: editor.lsp (diagnostics, code actions, LSP edits, semantic tokens, occurrences), editor.markdown (Markdown editing, lint, the 3-mode preview, its image pipeline and the HTML/clipboard/print exports), editor.completion, editor.fold (folding, the line-number gutter, sticky scroll, narrowing), editor.highlight, editor.language, editor.structured (the tree and summary previews and their PDF snapshots), editor.notes, editor.spell, editor.undo, editor.search, editor.git, editor.todo, editor.minimap, editor.logviewer and editor.crypto. The root keeps EditorBuffer and what every sub-package builds on (the overlay layer, line marks, caret and typing helpers): 54 types, down from 194. The Personal Notes hover moved out of EditorBuffer into NoteHover, which keeps the buffer under the 10,000-line cap. Classes and members other packages now call are public instead of package-private; state that used to be read as fields goes through accessors. Internal-only — no behavior, dependency, or module-info change.
  • Refactor: the debugger and HTTP-client presentation moved into com.editora.editor.debug and com.editora.editor.http. The breakpoint manager and gutter menu, execution line, inline values, debug hover and identifier scanner (10 classes) now live in editor.debug; the .http gutter, result marks, variable marks and fixes, hooks and completions (8 classes) in editor.http. The rule the split follows: com.editora.X holds a feature’s toolkit-free core and com.editora.editor.X its presentation inside the buffer. The overlay infrastructure those classes build on (OverlayPalette, CanvasGuards, AfterLayoutPaint, SecondaryPane, TabSurface, LineMarks, LineMarkTracker, CodeLensShift, MenuIcons, MarkdownLintOverlay) and the members EditorBuffer calls on the moved classes are public now instead of package-private; the JaCoCo per-package rule covers com.editora.editor.*. Internal-only — no behavior, dependency, or module-info change.
  • Null checking in the build. NullAway, an Error Prone plugin, now checks every package marked @NullMarked (JSpecify) during compile and fails the build on a null that is not declared. Every package is marked, the window UI (ui) last, so the whole code base is checked. A new package must start marked (docs/conventions.md, “Null annotations”).
  • Maven tool window (review pass 2). A module’s tree now merges the parent chain found beside it on disk (profiles, plugins, pluginManagement goal groups shown as managed, ${property} plugin versions resolved); profiles are tri-state (off, -P, -P!id) with their activation condition (JDK, OS, property, file) beside them, and the profiles your settings.xml activates are shown locked; the tree and the actions popup share one set of checked profiles. A bound execution runs as prefix:goal@id. Every first build in a Maven or Gradle folder that is not yet trusted asks once, wrapper or not, and the prompt lists what will run (the wrapper, the pom’s plugins, .mvn/ files, a project.json override); the tree header shows the trust state with Revoke, and the same gate fronts build-before-launch, the classpath fallback and “Load all tasks”. A project whose build files sit one or two folders below its root lists them under Projects; the detection never walks above the open project. Run custom prefills the last command, keeps a per-project history (Recent rows) and says which profile flags it will not add; Rerun Last names the folder. A Build submenu in the Run menu and default chords (IntelliJ Ctrl+Shift+F10, Alt+Shift+B) reach the Maven actions; the Maven submenu drops its “Maven:” prefix; a malformed pom keeps the lifecycle and shows the error with an Open pom.xml link; goal tooltips lose their Javadoc markup; Run is greyed until a task is selected; Settings and Doctor show which Maven a module’s build really runs (”./mvnw (trusted)” or “mvn on PATH”); the Default JDK hint names the tools it drives. Workspace state schema 22 → 23.

Fixed

  • Run: a second Run during a deployed configuration’s before-launch step no longer moves the program to this machine. The second Run was refused (“A program is already running”), but it cleared the launch’s deployment on the way, so when the step finished the program ran in the local project instead of the host’s copy. A deployed Java configuration lost its launch altogether. A refused Run now leaves the launch under way as it is. A Run during the deploy’s upload is refused the same way; it used to start a second deploy, which was refused but marked the first one ended, so Stop no longer cancelled the upload.

  • Null pointer exceptions found by the new null checking. Each would have failed the action, or a background thread, with a NullPointerException:

    • Terminal Find after a newer search or the terminal’s closing had already replaced the scan.
    • Debugger: a stopped event that arrived before the session’s client was set.
    • File watching (polling): a folder that could not be listed when it was first watched; its first readable listing is now the baseline.
    • Plugin registry: a download without a deadline, on a JVM whose nanoTime() is negative.
    • Test runner: a suite reported without a name.
    • SSH config: an Include ~… in a config with no home folder above ~/.ssh.
    • Install: a destination at the root of a drive (now a clear error).
    • Scala Run: a file path ending in /...
    • Local History: an iterator remove() before next() (now the IllegalStateException the contract names).
    • Node.js Run: a configuration whose script is not a valid path (on Windows, one with < in it): the run never started and said nothing; it now asks for the script.
  • Markdown: switching to Preview no longer sometimes opens it at the top. Switching just after a highlighting pass (soon after opening or editing the file) showed the start of the document, not the line the editor had at its top. That line now carries over every time.

  • Opening a root as a file no longer throws. editora / (or editora D:\), and Remote > Open File on sftp://host with no path, used to hit a NullPointerException in the open path. From the command line that stopped the session restore and left an empty window. Now the status bar says the path is a folder, and no tab opens. A session entry that names a root is dropped instead of restored.

  • Remote: a 2FA code asked after the password no longer says “That was not accepted. Try again.” A server that asks in rounds (a password, then a code) had each round counted as another try; only the same question asked again is a retry now.

  • Remote: a login or host-key question left unanswered for two minutes closes its dialog. The login gave up but the dialog stayed on screen, and an answer typed into it went nowhere.

  • Maven: the submenu acts on the pom it was opened on. Right-click moduleB/pom.xml (or its folder) and Update Versions, Show Actions and Run custom now read, list and run that module. They used to act on whichever module the active editor tab was in, so a version update could rewrite the wrong pom. The status line names the folder when it is not the active tab’s. Rerun Last and Stop are window-wide and left the submenu (the palette and the tool window keep them).

  • Maven: a module can build from its reactor root. In a multi-module project the Maven tool window starts with a Reactor section whose toggle runs every task as mvn -f <root>/pom.xml -pl <module> -am …, so compile or test in a module that depends on a sibling no longer fails with “Could not find artifact” until the sibling is installed. Offered only when the root pom lists the module and the root is inside the open project.

  • Maven: Update Versions and the New Project wizard order versions as Maven does. Versions are compared with a port of Maven’s ComparableVersion, not a semver comparator: Update Versions no longer proposes a downgrade such as guava 33.0.0-jre → r09, and a candidate whose leading number is below the current one, a property reference (${surefire.version}), a range or LATEST/RELEASE is never offered. The wizard’s “Update dependencies and plugins to the latest versions” resolves dependencies through the same Maven Central path and stable filter as plugins. It used to run versions:use-latest-releases, which wrote milestones, betas and alphas (7.1.0-M2, 8.0.0.Beta3, 5.0.0.Alpha2) into brand-new projects. The status reports both counts.

  • Maven: “Load full catalog…” works again. Maven Central’s 18 MB archetype-catalog.xml is streamed (no DOM, no 16 MiB or 20,000-row cap) into one row per archetype at its newest version (about 3,800 rows), cached under ~/.editora/cache/archetype-catalog.json for a day and then re-checked with a conditional request; picker rows show groupId:artifactId:version before the description. The curated list now holds only archetypes that generate and build on a current JDK: maven-archetype-plugin and -site 1.5, Camel 4.23.0; the Quarkus row (a plugin, not an archetype) and the 2010 Scala row are gone.

  • Run and Debug Main Class in a Maven or Gradle project build first. Maven compile (test-compile for a class under src/test) or Gradle compileJava runs in the Run/Debug console before the launch and a failed build aborts it, so a fresh clone no longer dies with ClassNotFoundException and an edited file no longer runs the previous binary (jdtls runs with autobuild off). Settings → Build Tools → “Build before Run and Debug” (on) turns it off; a run configuration with its own before-launch step keeps that step. The no-jdtls Maven fallback resolves the classpath with the same Maven the Maven window runs (./mvnw once trusted, the command override, else PATH mvn) instead of a hard-coded mvn, in the Run console: its output streams, Stop ends it, a second Run is refused while it runs, and a failure’s status quotes Maven’s first [ERROR] line instead of “Could not resolve the classpath.”; the program’s classpath carries the runtime scope only. A before-launch step may be symbolic (maven:compile, gradle:compileJava), resolved through the same executable at run time; a generated Maven project’s configuration stores that. A launch that ran without the build prints a hint to build when the JVM cannot find the main class. Settings schema 141.

  • Maven pom.xml server (lemminx-maven): repaired install, honest status. The Maven-aware pom.xml server Editora installed could not answer a single request: lemminx-maven’s “zip with dependencies” leaves out Guava, Commons Lang and jsoup, so every completion, hover, definition and outline failed inside the server while the status bar said “Loaded and ready”. Install… now also downloads those three libraries from Maven Central (pinned by version and SHA-256) into the same folder and, before keeping an install, starts the server and asks it one hover request; an install whose server cannot answer is refused with the reason. A folder that lacks jars (an earlier install, a wiped folder) is no longer “found”: pom.xml falls back to the XML server, Settings → LSP shows “lemminx-maven: incomplete — Install… repairs it” and Doctor names the missing jars. Any language server that answers a request with an internal error is now logged with the server’s detail and announced once per request kind (“lemminx-maven: internal error on hover — see the log”); three failures in a row stop the server (Restart Language Servers retries) and Doctor shows it as a warning; hover says “Hover failed: …” instead of “No documentation at the caret”. Existing installs: click Install… once.

  • Debug Test on a Maven project attaches again. Surefire 3 withholds the JDWP “Listening for transport…” banner until the suspended test JVM has run, so waiting for it hung the run forever. Editora now picks a free loopback port before the launch, passes it in -Dmaven.surefire.debug, and attaches as soon as the fork listens on it (a further fork of the same run is attached after the first finished; after 60 s without a listener the status says so). While it waits, the Test Results header reads “Debug: waiting for the test JVM to open port N…” instead of the whole Maven argv, the status-bar message is no longer overwritten by “Maven: running test…”, and Debug ▸ Stop ends the Maven run before a session exists. The JVM prints one “Debugger failed to attach: handshake failed” line in the Build Output: that is Editora’s port check, not an error. Gradle is unchanged.

  • Maven: New Maven Project and Update Versions (review pass 2). The wizard runs Maven on the JDK chosen in Settings → Build Tools, opens the Output window while it generates, and shows the archetype’s own properties (JavaFX version, JUnit version, …) with their defaults once the archetype is in your local repository; the Java release goes through quickstart’s javaCompilerVersion. The form says which field blocks Create, accepts a relative or ~ location and shows the folder it means, allows an existing empty folder, derives a lower-case package, and the generated pom.xml opens in the new project’s window. A project generated inside an open aggregator stays a module of it instead of becoming a second project. A JavaFX archetype gets no java run configuration (it cannot launch that way); the wizard says to run it with javafx:run. The consent prompt names the archetype’s repository, “Trust and Generate” skips it for the rest of the session, and Cancel returns to the form. Update Versions shows a checkbox per row under Dependencies / BOM imports / Plugins / Parent, tags a major jump, counts what it did not check (property-driven, inherited), offers the parent pom from a module and the property itself when a version is ${property} used only there; the Central lookups run in parallel under a background task, stop at the first connection failure, and a second invocation cancels the first. Counts are pluralised; the wizard’s Output tab is “New Project”.

  • Maven / Output console (review pass 2). [ERROR], [WARNING], BUILD SUCCESS and BUILD FAILURE lines keep their colours under every editor theme; Maven’s compiler locations (App.java:[5,18]) are clickable, column included; a build you stop reads Stopped in the console header, the status bar and Test Results instead of “exit code 143” / “Run failed”; starting a task while another runs offers Stop and run; the console keeps the previous run behind a header toggle, has a find bar and Save output….

  • Run, Debug and Test on Maven (review pass 2). Run’s Maven fallback and the build before Run/Debug find a module’s reactor through the poms’ <modules> (a modules/ folder without a pom included, never above the open project), build from the root with -pl <module> -am only when the root lists the module, fall back to the module alone when the reactor does not hold it, and say in the Run console which mode ran; both carry the Maven window’s checked profiles and flags. A saved configuration resolves the module its project name or main class belongs to, whatever file is active; with no Maven JDK selected the program runs on $JAVA_HOME’s java, the one Maven compiled with. Remote hosts get a maven tool beside the JDK (Settings → Remote → tools); the host’s build streams into the Run console and Stop ends it. A hand-typed -Dtest= that matches nothing reads “no test matched”; Test Results marks retried and flaky tests with their retry traces and reads a custom Surefire or Failsafe report folder; Debug via build tool warns when the Boot plugin configures jvmArguments and says so after 45 s without a debug banner; a generated project’s configuration keeps a blank working directory (the project root).

  • Maven pom.xml editing (review pass 2). The pom summary preview now reads the parent chain beside a local file and the BOMs it imports from the local repository, so a managed version shows its number with its source (from reactor-parent 2.0.0, from junit-bom 5.11.0 (import)); “inherited” is said only under a declared <parent> and a dangling ${…} reads “unresolved”. Rows take you to their element, section titles collapse (Properties starts collapsed on a long pom), a filter narrows the rows, Dependencies come before Properties, and repositories (flagged when not Maven Central), reporting plugins, URL/SCM and each profile’s activation conditions are listed; a malformed pom names its line and column. Names never break mid-word in a narrow split. Same-named open files show their folder in the tab (“pom.xml · core”), the Structure window names a pom’s dependencies, plugins and profiles, a pom gets Maven snippets (dep, plugin, profile, …) and there is a “Maven pom.xml” file template. The Maven language server runs on the Build Tools JDK (also for Install…), serves a whole reactor from one JVM without a project, announces “ready” only once its Maven initialization is done, names its diagnostics, hides ${…} property items from artifact completion unless you type $, and Settings → LSP can turn on the Maven Central index (off by default: local repository only). The native XML server is shown as “lemminx”. Settings schema 141 → 142.