Everything shipped in the 0.25.x release series, straight from
the changelog. Each release's announcement, with the highlights, is on
News.
[0.25.0] - 2026-10-26
Added
Help → Report a Problem… (help.reportProblem, also a button in the Debug Log window) and editora --report: a problem report from the debug log (this session’s and the one before), with the version, Java,
OS and plugins. Paths in the home folder, the user name, e-mail addresses, credentials in URLs, authentication
headers and token-shaped values are replaced first, and the report is shown, editable, before anything leaves
the machine. Open GitHub Issue copies it and opens a new issue with it filled in (a report too long for the
link is pasted from the clipboard instead); Copy and Save… are there for any other channel. --report writes
the file to the current folder and opens the issue, for when Editora will not start. Nothing is sent by Editora
itself: the user submits the issue. A new bug-report issue form (.github/ISSUE_TEMPLATE/bug_report.yml) has
the fields the link fills.
Run: Run Context at Caret (run.context; Ctrl+Shift+F10 / ⌃⇧R in the IntelliJ keymaps, as IntelliJ’s Run
Context Configuration): runs the test at the caret (the whole test class above its declaration), else the class’s
main as its ▶ does, else the file; a Java class with neither says so. The chord used to rerun the last Maven goal.
Find Action knows other IDEs’ names. The command palette also finds commands by what IntelliJ IDEA and VS Code
call them: Optimize Imports, Show Context Actions, Reformat Code, Find Usages, Parameter Info, Insert Live
Template, Go to Test, Copy Reference, Show Call Hierarchy, Find Action, Super Method and others. The whole of
such a name leads the titles it only fuzzily matches, so “go to test” finds Related File first. A command’s own
title, typed, comes before another command’s other-IDE name.
Go to Super Method (lsp.gotoSuperMethod; Ctrl+U / ⌘U in the IntelliJ keymaps, in Navigate and the editor’s
LSP submenu): from anywhere in a method (its @Override and Javadoc too, an anonymous class’s method included,
in a method, a field, an initializer or an enum constant), the method it overrides or implements: jdtls’s answer,
and the type hierarchy for what it misses, so an interface’s default method and a method two interfaces declare
go to each, and of two where one overrides the other, the nearer alone. A static or private method, or another
overload, has none. In a lambda, its functional interface’s method; in a constructor, the super constructor it
calls, through this(...) too; on a type, its supertypes, the superclass first and each named by its type; a
picker when there are several. It works the same in a library source tab, and says it is looking when a deep
hierarchy takes a moment. A type parameter of any name (Store<Item>, Handler<Req, Res>) stands for the type
it is given, and a method marked @Override is looked for up the hierarchy when jdtls finds nothing, as for an
inner class of a generic class.
More IntelliJ and VS Code chords. IntelliJ keymaps: Ctrl+I implements methods on Linux, Ctrl+Shift+= / - (⌘⇧= /
⌘⇧-, and the numpad’s Ctrl+Shift++ / -) expand and collapse all folds, Ctrl+Alt+Shift+C copies the qualified name,
Ctrl+Alt+F7 finds usages, and menus name Alt+Enter for Code Actions. VS
Code keymaps: Ctrl+F12 Go to Implementation, Alt+F12 Peek Definition,
Ctrl+T Go to Symbol in Workspace.
Doctor names the Java jdtls runs on, with its version, and warns when its launcher’s python3 is missing, when
no Java new enough for the installed jdtls is found, and when the JDK the window’s project gets (the release its
build file states, ${…} properties, Spring Boot’s java.version, a Kotlin jvmToolchain and a reactor’s
modules read, else the default) has no sources (arg0 parameters), naming each and the package that adds them.
Navigate and the editor’s LSP submenu list more code navigation. Navigate lists Go to Declaration, Peek
Definition and Copy Qualified Name; the editor’s LSP submenu lists Call and Type Hierarchy.
Code-action lightbulb in the gutter (IntelliJ’s intention bulb). When the caret rests on a line where the
language server has a fix for an error, a red bulb with a ! shows in the gutter; an amber one for other quick
actions, a warning’s included. Refactorings, source actions and Add Javadoc, which servers offer nearly
everywhere, light nothing. Click it for the list Alt+Enter shows, for its own line; its tooltip names the chord.
It goes as soon as the caret leaves the line or the line is edited, shows only in the focused view of a split and
never asks for a tab that is not on screen (it keeps its bulb, and asks again when shown), takes its colours from
the editor theme (accent and danger in themes without their own; the foreground colour in Summer Dark, Navy Dark,
Fall Dark and Blacky, whose accent is the bookmark’s yellow), and
never shifts the text: it uses the bookmark column. Settings ▸ Code Completion ▸ Language server features, on by
default.
Problem counter at the top right of the editor (IntelliJ’s inspection widget): the file’s errors and warnings
with their glyphs, or a green check when the server found none, and previous/next arrows that go through that
file’s problems. Click the counts to show or hide Problems. It says Analyzing… until the server has checked the
file (for Java, until the project is loaded: jdtls’s first, empty list is no check), again after a restart, and
Not checked when its project did not import. Shown while a language server checks the file and the
code pane is at least 520 px wide; a setting beside the lightbulb’s turns it off.
Settings schema 146→147, additive.
Doctor: Check for Newer Versions. A button in Doctor’s header asks npm, the Go module proxy, GitHub and
HashiCorp for the latest release of each working language server or tool that Editora installs at its latest
release (Pyright, typescript-language-server, the JSON/HTML/CSS, Bash, YAML, Dockerfile, TOML and Astro servers,
gopls, clangd, lua-language-server, tinymist, terraform-ls and the Mermaid CLI). Ones with a newer release move to
Updates available at the top, with Update…. Nothing is looked up until you click, and a Refresh keeps
what the check found. Pinned servers are not looked up: a new Editora release brings their new versions.
Doctor: Update for a TypeScript server without tsserver. The warning for a typescript-language-server with no
TypeScript, or with TypeScript 7 (which has no tsserver), now has the Update… button its tip mentioned; it
reinstalls the server with TypeScript 6. Update on a row of the Java, Python or JavaScript support now
reinstalls only that row’s tool.
Settings sync carries your shortcuts. A new Shortcuts switch on Settings ▸ Sync (on by default) syncs
the key bindings you changed, in every keymap and for both Windows/Linux and macOS, as keybindings.json in the
sync repository. They merge chord by chord like snippets; which keymap each computer uses stays its own. A change
syncs shortly after you rebind, reset or switch keymaps. Settings schema 145→146, additive.
Surround With (snippets.surround, Code ▸ Surround With…; Ctrl+Alt+T / Cmd+Alt+T in the IntelliJ keymaps)
lists only the snippets that wrap a selection and puts the selection inside the chosen one; with nothing
selected it wraps the current line.
Java: Excluded types (Settings ▸ Code Completion ▸ Language server features): the packages and types
completion, auto-import, Go to Symbol and Search Everywhere leave out. The default is vscode-java’s list,
which includes java.awt.*. Settings schema 144→145, additive.
Go to Implementation lists library implementations. When an implementation lives in the JDK or a dependency,
every implementation is listed in a picker with its package, instead of one being opened with no word of the
others.
Doctor: Update for servers and tools older than Editora’s. Editora installs jdtls, the JavaScript debugger,
the Maven pom.xml server, Groovy’s gls, Metals, the Kotlin server, clojure-lsp, ShellCheck and shfmt at the
exact release it is tested with. When a new Editora moves to a newer release, Doctor now marks a copy installed
under the old one with a warning that names both versions and an Update… button, which installs the new
release and restarts the server on it. Each install now records its version (.editora-install in its folder);
for copies from before this, Doctor reads the version from the files or from --version where it can, and
offers Update where it cannot tell (a Kotlin server from an earlier Editora). Install also replaces Editora’s
own copy that is known to be older, as it already did for jdtls.
A Clojure debugging sample.samples/debug/clojure/ is the same shelf as a small standalone Clojure CLI
project (four namespaces, a script, six green clojure.test tests) with a break here comment at every spot
worth a breakpoint: a loop/recur whose bindings change on every pass, an anonymous fn, a recursion, three
named worker threads, a caught and an uncaught exception, and a script’s top-level forms. clojure -M:run
and clojure -M:test run it outside Editora.
Complete Statement (edit.completeStatement, Code ▸ Complete Statement; Ctrl+Shift+Enter / Cmd+Shift+Enter in
the IntelliJ keymaps), as IntelliJ’s Complete Current Statement: in Java, C, C++, C#, JavaScript, TypeScript, PHP
and Kotlin it closes the line’s open string and brackets, adds the ; (not in Kotlin) or the { } block a
control header, type or method needs, and leaves the caret where the next code goes. A finished statement gets a
new line below; other languages get Insert Line Below. Every caret, one undo step.
Java: Smart Type completion (lsp.smartTypeCompletion, Edit menu; Ctrl+Shift+Space in the IntelliJ keymaps),
as IntelliJ’s: the completion list holds only what fits the type expected at the caret. The type comes from a
declaration (String s = ), an assignment, return (the method’s return type), a condition (if (, &&) or
a call’s argument (signature help). Fields, variables and methods of a fitting type stay, null for an object
and true/false for a boolean; after new, the classes that implement the type. Where the code states no
type the full list opens, and the status bar says so.
One Java server per project, whichever windows it is open in. A second window on a Java project joins the
jdtls the first one runs instead of starting another, which imported the project again on a second
workspace and used as much memory again (about 1.5 GB). Both windows see its diagnostics; a question the
server asks goes to the window you are working in. Closing one window leaves the server to the other, and
Restart Language Servers in either restarts it for both.
Java: organize imports and format on save. Two settings under Settings ▸ Code Completion ▸ Language server features: after you
save a Java file, jdtls organizes its imports and/or formats it, and the file is saved again when that changed
it, as IntelliJ’s Actions on Save do. Both are off by default; autosave never runs them, and an ambiguous import
is left out rather than asked about. Settings schema 143→144, additive.
Java: clean-ups.Code ▸ Clean Up File applies the jdtls clean-ups chosen under Settings ▸ Code
Completion ▸ Language server features (add @Override and @Deprecated, drop redundant modifiers, qualify
members, add final, pattern-matching instanceof, switch expressions, lambdas, try-with-resources, text
blocks and more; 19 in all, four on by default). Clean up on save (Java) runs them after an explicit save,
before organizing imports and formatting.
Java: Lombok on request. A project whose build declares Lombok but has not downloaded it yet is offered
Lombok 1.18.48 from Maven Central (checked by SHA-256 into plugins/lsp/lombok); its Java server then restarts
with Lombok as its agent.
Java: a project’s own code style reaches jdtls. IntelliJ’s import settings in .editorconfig
(ij_java_imports_layout, ij_java_class_count_to_use_import_on_demand,
ij_java_names_count_to_use_import_on_demand) become jdtls’s import order and * thresholds, and the Eclipse
formatter profile the build formats with (Spotless’s <eclipse><file> or eclipse().configFile(…), else an
eclipse-formatter.xml at the root) is what Format Document uses.
Java: chain completion. In an argument or assignment, completion also offers calls that produce the
expected type, such as Collectors.toList() inside collect(.
Java: Extract Method, Variable and Field at the caret, Introduce Parameter, and a warning before a risky
move. Editora now declares jdtls’s inferSelectionSupport: with nothing selected the extract actions are
offered, and Editora asks the server which expressions are there and lets you pick one when there are several.
Introduce Parameter is offered as its own refactoring. Extract to Field and Convert Local to Field ask where
to initialize the field when there is a choice. A Move Instance Method that jdtls finds problems with (jdtls
1.61 final and newer) now shows those problems and moves only if you continue; before, it was applied anyway.
Java: Go to Symbol in Workspace finds methods and JDK or library types. jdtls was never asked for method
symbols, and its matches inside JDK or dependency classes (jdt://) were dropped. They are listed after the
project’s own, labelled with their module or jar, and open as library source.
File structure in the Project Map. A file row whose language the Structure tool window can outline
(Java, Python, JavaScript/TypeScript, Kotlin, Markdown headings, Typst, .http requests, Clojure, poms…)
gets a Structure icon before its preview eye. It opens a column of the file’s declarations, the way a
folder’s chevron opens its children; a declaration that holds others — a class’s members, a heading’s
subsections — has a chevron of its own and opens a further column, and a file with one top-level type opens
its members straight away. Clicking a declaration opens a floating preview card of only its lines: its block
with the doc comment and annotations above it, numbered as the file numbers them (in the narrowed amber),
coloured as in the editor, sized to fit, and titled “App.java › add()”. Open goes to the declaration; Open
Narrowed, in the card’s and the row’s menu, opens the file narrowed to the declaration’s fold block, as the
Structure window’s Narrow to fold region does. Several declarations of one file can be open side by side
under the usual eight-card limit. The columns and cards follow edits: an open file’s unsaved text is what is
outlined (with the language server’s symbols when the Structure window has them), a closed file is read
again when it changes on disk, and a card whose declaration was removed keeps its last lines and says so.
The arrow along the flow opens a file’s structure, Enter on a declaration opens its card, and the columns
are part of Print and PDF output. Nothing about it is remembered across restarts.
About says whether Editora is up to date. Under the version, the About panel now reads “You are up to date.”
or “Update available: X.Y.Z” (a link to that release), then when the last check answered and a Check now
link that asks GitHub again and updates the panel in place, failures included. Before any check has answered it
says so instead of claiming anything. The answer is kept in the preferences (latestReleaseVersion,
latestReleaseUrl, lastUpdateCheckOkEpoch; settings schema 142→143, additive), so it survives a restart: the
status-bar update notice now also comes back after a restart until the release is opened or installed, instead
of waiting for the next day’s check.
Java: Undo Last Refactoring. A rename, move or other refactoring that changed several files can be undone in
all of them at once: Undo in one of its files asks whether to undo it everywhere, and LSP: Undo Last
Refactoring does it from the palette. Renamed files move back and created ones are removed. Before, Undo
reverted one file and left the rest of the project renamed.
Java: renaming a .java file or a package folder in the Project tree renames the class or package. The
tree asks jdtls (workspace/willRenameFiles) for the edits first, so references, package lines and imports
follow; before, the class kept its old name and the project stopped compiling.
Java: Generate, Refactor This and a command per refactoring.LSP: Generate… lists the generators
(getters/setters, constructors, toString, equals/hashCode, overrides, delegates), LSP: Refactor This… the
refactorings at the caret, and Extract Variable / Constant / Field / Method, Introduce Parameter, Inline, Move,
Change Signature and Override/Implement Methods each have a command that runs the one jdtls offers there. They
are in a new Code ▸ Refactor submenu; before, all of them were reachable only through the quick-fix list.
Next / Previous Problem and Show Problem at Caret. Jump between the file’s errors (warnings when there
are none) and read the one under the caret without the mouse.
The “IntelliJ IDEA” keymap uses IntelliJ’s Java chords: Alt+Enter for quick fixes, Shift+F6 Rename,
F2/Shift+F2 next/previous problem, Ctrl+F1 problem at caret, Alt+Insert Generate, Ctrl+Alt+L/O format and
organize imports, Ctrl+N / Ctrl+Alt+Shift+N symbols, Ctrl+Alt+B implementations, Ctrl+Shift+B type,
Ctrl+H / Ctrl+Alt+H hierarchies, Ctrl+P parameter info, Ctrl+Alt+V/C/F/M/P/N, F6 Move, Ctrl+F6 Change
Signature, Ctrl+Alt+Shift+T Refactor This, Ctrl+O Override, Ctrl+Alt+Left/Right Back/Forward (and the macOS
equivalents). F2 is no longer Rename and Alt+Insert no longer New File (now Ctrl+Alt+Insert) in that keymap.
The default Emacs keymap gains a C-c l prefix for the language-server commands, M-g M-n/M-g M-p for
problems and M-,/C-M-, for back/forward; every keymap now binds Back and Forward.
LSP: Clean Java Workspace and Restart. Stops the project’s Java server, deletes its index and the classpath
and source folders it worked out, and imports the project afresh — the cure for a stale or corrupt jdtls
workspace, which Restart Language Servers kept and Clear Java Index Caches skipped while in use.
Java: navigation inside library source. In a JDK or dependency tab opened by Go to Definition, hover, Find
References, Go to Implementation / Type Definition / Declaration and the call and type hierarchies now work, asked
of the server that opened it; before, only Go to Definition did and the rest said “No language server for this
file”. JDK and library nodes in the hierarchies open as library source too.
Java: /** gives the declaration’s Javadoc. Typing /** above a method or class closes the comment and offers
jdtls’s “Javadoc comment” template, with @param, @return and @throws for that declaration. Enter instead
still splits the comment as before.
Java: rename what an extraction created. After Extract Method, Variable, Constant or Field the caret is on the
name jdtls picked (d, getTotal) and Rename opens on it.
Java: Search Everywhere finds JDK and library classes. With a Java server running, List, Assertions and
the other classes the project’s index cannot see are listed under Symbols after the project’s own, and open as
library source.
Format Document formats only the selection when there is one (textDocument/rangeFormatting), whole lines,
as IntelliJ’s Reformat Code does; before, the whole file was reformatted under a selection.
Change Signature and Move show their files before applying. When they change other files, the rename preview
lists them, ticked, and an unticked file is left alone; before, both applied unseen.
Related File (test ⇄ subject) is in the Navigate menu, and on C-c S-t (C-c T) in the Emacs keymap.
Java: Lombok. jdtls runs with Lombok as its Java agent for a project whose build declares Lombok (Maven
org.projectlombok, Gradle’s Freefair plugin), using the newest Lombok jar already in the local Maven or Gradle
cache, as vscode-java does with its own. Before, every getter of an @Data or @Getter class was an error.
Nothing is downloaded: a project built for the first time gets it when its server next starts.
Java: null analysis from the project’s annotations. With JSpecify, javax.annotation, Spring or Eclipse
null annotations on the classpath, jdtls checks @Nullable and @NonNull use, as IntelliJ’s inspections do.
Java: static members of JUnit and Mockito are completed without an import (assertEquals, mock,
when…), and the static import is added.
Surround With. Insert Snippet over selected lines wraps them in the Java if, for, while, do, try
and synchronized snippets, re-indented; Ctrl+Alt+T (Cmd+Alt+T on macOS) in the IntelliJ keymap. A snippet’s
multi-line variable now keeps the indentation of the line it is on.
Java: Move into a new package. Move’s package list ends with “New package…”: type the name and the folder
is created under the current source root and the file moved there.
Java: Related File offers to create a missing test. On a class under src/main/java with no test, it offers
a JUnit 5 test in the same package under src/test/java, and opens it.
Changed
IntelliJ keymap: Ctrl+J / ⌘J is Insert Snippet (IntelliJ’s Insert Live Template), which lost its only chord
when Ctrl+Alt+T became Surround With.
Menus drop the palette’s category prefixes (“Edit:”, “Go:”, “Snippet:”) where the rest still says what the
row does, as they already dropped “LSP:”.
Completion matches camel humps first:vO puts valueOf first and st finds toString; two typed
letters no longer match letters scattered through a name.
IntelliJ keymap (macOS): ⌘N is Generate in the editor, as in IntelliJ, and New in the Project tree; New File
moves to ⌃⌘N. ⌃I is Override/Implement Methods, and ⌘[ / ⌘] go back and forward. On Linux and Windows,
Alt+Insert is New in the Project tree too.
Generate (Alt+Insert) lists only generators, and Override/Implement Methods sits next to it in the Code menu;
jdtls’s generator quick assists no longer crowd Alt+Enter, and Inline (Ctrl+Alt+N) no longer offers Make
Static.
Menu rows drop the palette’s “LSP:” prefix, and the editor’s LSP submenu gains Peek Definition, Refactor
This… and Generate….
Go to Symbol and Search Everywhere rank the exact class first and a library class nested in another last,
and leave out the excluded types (no more sun.* or Arrays.ArrayList above java.util.ArrayList).
The Default JDK’s hint says what it drives (Gradle imports and the Java server’s default JDK too), and
changing it while jdtls runs says to restart the language servers.
Plurals: “1 file”, “1 change”, “1 reference”, “1 item” in the References, Problems, hierarchy, rename
preview and refactoring-undo counts, in all six languages.
Project Map preview and note cards move and zoom with the map. Panning carries a card along with the
columns under it, zooming scales it with them (the card’s − / + still sizes its text on top), and a card can
be dragged past the edge of the visible canvas the way a column can, instead of stopping at the panel’s edge. Its resize grip now allows up to the panel’s
size wherever the card stands, and resizing the panel no longer pushes cards back inside it. Whatever part of a
card lies outside the map is clipped, so a card never paints over the Map’s filter bar or breadcrumbs.
Refactor: the preview’s right-click menu owns its own state and moved to editor.markdown.PreviewMenu is now an object the buffer holds: the seven export and print actions the window injects, and what the pointer was on when the menu opened, live in it instead of in eleven EditorBuffer fields read from outside. The window injects the actions through buffer.previewMenu() (setExportPdf, setPrint, …) in place of seven setPreview…Handler setters. EditorBuffer is 58 lines shorter, which restores room under the 10,000-line cap. Internal-only — no behavior, dependency, or module-info change.
jdtls is pinned to 1.63.0 (from 1.62.0), checked against the jdtls probes. Doctor now names the installed
jdtls version and warns when it is older than the pinned one, and Install replaces an older copy of Editora’s
own instead of saying it is already installed. Installs made before a pin bump used to keep their server for
good.
Java files up to 50,000 lines keep the language server in the large-file tier, as Python files do. jdtls
checks a 12,000-line file in well under a second; above 10,000 lines Java files lost diagnostics, completion
and navigation.
One Java server per Maven reactor or Gradle build outside a project. Opening files of two modules of one
reactor in a window without a project started a jdtls per module (1.4 GB each) that could not see the other
module; the root is now the reactor’s or the Gradle build’s. A second window on a project another window
already serves says that it starts a server of its own.
Simple mode shows the language-server loading bar, so a server importing a project in the background is
visible.
Fold All leaves a Java, Kotlin, Scala, Groovy or C# file’s one top-level type open and folds its members,
imports and comments, the outline IntelliJ’s Collapse All gives; before, the file folded to a single line.
Type Hierarchy on an interface opens on its subtypes, the implementations, instead of an empty Supertypes view.
The References window shows code for files without a tab, read in the background, names each file’s folder so
two Main.java can be told apart, and says what was searched (“5 references to area in 4 files”). It no
longer lists the declaration itself.
Completion, quick-fix, hover and signature popups open above the caret line when there is no room below it,
instead of being pushed up over the line being typed.
Static methods and nested types are italic in their own colour, as in IntelliJ; before, a language server’s
static modifier gave them the constant colour, so String.format read like a field.
Java: Generate hashCode() and equals() starts with every field ticked, and Enter with nothing ticked in a
Generate list says so instead of closing silently. The list’s rows are taller and it shows twelve at a time.
Java: Move lists the test source folders’ packages after the main ones, so a main class is not moved into
src/test by picking the first of two identical package names.
Peek Definition works in library source and peeks it. From a JDK or dependency tab, and on a definition
inside one, the peek window shows the library source, on the declaration, instead of opening a tab.
A member called more than once is one row in Call Hierarchy, with the count (“append(String) ×2”).
The References window marks the references that write — an assignment, +=, ++ — with “(write)”.
Refactor: the text model the editor shares with other packages moved to a new com.editora.text. The LSP value types (LspTextEdit, LspDiagnostic, SemanticToken, OccurrenceSpan), FoldRegions, the search matcher with CaseFold and SearchMatches, all of language detection (LanguageRegistry, LanguageNames, ConfigFileType, ShellFiles, ShellScripts, Shebang, Modeline) and EncryptedNames leave the editor sub-packages, with 13 tests. lsp, search, crypto, template and editops no longer depend on the editor; editor.language is gone, its classes having no presentation in them. text has its own 0.95 coverage floor. Internal-only — no behavior, dependency, or module-info change.
Refactor: the editor’s toolkit-free helpers moved to the core packages they belong to.AceLabels,
LineEndings, RegexLiterals, TextNav, TextFingerprint and WholeDocumentEdit go to com.editora.editops;
CompactSource to com.editora.run, CodeLessLines to com.editora.dap, PomFiles to com.editora.maven and
RulerColumns to com.editora.config, each with its test. com.editora.index no longer depends on the editor at
all. PomFiles.snippetLanguage(buffer, language) became EditorBuffer.snippetLanguage(language), so maven does
not reference the editor either. The classes that are the buffer’s own state or reference the editor stay:
SavedBaseline, DocumentSnapshots, WordWrap, LineMarks, TabSurface, RunScan, and CodeLensShift, which
works on RichTextFX types. Internal-only — no behavior, dependency, or module-info change.
Fixed
The Default JDK is recognised when it is reached through a symlink. jdtls’s default runtime and the Java it
runs on compared the Default JDK’s resolved path with each JDK’s path as found, so a JDK listed through a link (or
macOS’s /var → /private/var, a Windows short name) lost its place as the default.
Markdown: with scroll sync off, the preview no longer jumps once. A follow queued while sync was on still ran
after it was switched off; it now checks again. A mode switch still hands the position over.
A crash’s log is no longer erased by the launch after it. Each start truncated editora-session.log, so the
log that recorded a crash was gone by the time Editora was reopened to report it. The previous session’s file is
now kept as editora-session.prev.log (left out of config exports, like the session log).
Java: a jdtls Update no longer leaves other windows without a server. Doctor’s Update stopped jdtls in every
window but started it again only in the one that ran it. Every window now says the server is paused while it is
updated, and reopens its Java files when it is done (failed or not); none of them restarts the old server
meanwhile.
Java: Restart restarts only this project’s jdtls. With two projects on one server each, Restart stopped both
and cleared both projects’ problems. Reload Project Configuration now ends on “Loaded and ready”, status lines
name a folder only while two servers run (starting ones included), and a failed import’s reason is named by its
folder too. Reload or Clean in one project keeps another project’s failed import and Problems entries, so fixing
that one’s build file still imports it again; a second window on a project that did not import says so and lists
the project’s own problems; a failed import is one error, in the project’s own words; one that joins while jdtls
is still importing waits for it to be ready, rather than
saying “Loaded and ready” over files not yet checked; and a fix saved in one window clears the old build error in
the others.
Java: jdtls starts when JAVA_HOME is a JDK 21. jdtls 1.63 needs Java 25 though its launcher checks for 21,
so it crash-looped; Editora reads what the installed jdtls needs at every start (an Update in place included) and
runs it on a newer JDK it found. With none, the status says “jdtls needs Java 25…”, and it stays said (logged
once).
Java: the import chooser waits for you. Organize Imports and Add all missing imports gave up after 30 s while
the chooser was still open, and the answer imported nothing; no request times out while it asks, and it closes
when the server ends (a restart). A second Organize Imports while it asks says to answer it first, a save runs
none of its on-save actions (clean-up, organize, format) under it, and an answer the file has changed under says so instead of “the server gave up”.
Java: an open file sees an API changed in another. Rename a method in one file and save: another open file
that calls it showed no error, its counter included, until it was typed in. A Java save now rechecks the project
quietly when another of its files is open, in this window or another sharing its jdtls, as it did only while
Problems showed the whole project. Outside a Maven project the open files are rechecked without a build, which
would compile a Gradle project into bin/.
A tab chosen by its header or by Window ▸ Next Tab has the keyboard focus in its editor, and so has the tab
shown when the focused one is closed or split off, or after a right- or middle-click on a header. It stayed on the
tab pane, the breadcrumbs or the toolbar’s New button, so the first keys went nowhere, the arrows switched tabs and
a Space opened a new buffer.
Command palette: one word leads only as a whole title. “rename” and “find” in a Java file chose the
terminal’s Rename Tab and Find over Rename Symbol and Find in Files, while “project” and “terminal” still open
their tool windows. The terminal’s own commands are grayed while no terminal is open.
A jump into a file already open says nothing, rather than “Already open: Shapes.java”.
Java: navigation from a library source tab opens library targets. Go to Super Method, Go to Type Definition
and a row picked among implementations did nothing from a jdt:// tab when the target was another library class.
Fold All, Unfold All and the other fold-everything commands keep the caret on its line, or on the fold that
hides it, and on screen. Each region folded moved it to that region’s header, so it ended in another method, off screen.
Search Everywhere lists library classes as Go to Symbol does: Map.Entry among the first rows for “Entry”,
not 16th, past the group.
Go to Implementation names a nested library class by its own name (AbstractList.SubList), not its outer
class’s.
Java: Reload after a failed Gradle import works from build.gradle. Run from the build file’s tab, which the
failure message points to, it updated a project that did not exist. Saving the fixed build file now imports the
project again too.
Java: refactorings keep jdtls in step. A refactoring that edits a tab jdtls never opened opens it there, so a
second refactoring before a save no longer skips it. A drag-move of several files is one refactoring: Undo Move
and Undo Last Refactoring each take all of it back, every file’s edit included (also when a file the move edits
is open in a tab), and either ends the other; the status says what moved and what was kept, not the save’s “Saved”
line, and a move whose edit failed as a failure (“Nothing moved; 1 not moved…”), without covering the warning
that a package line was left as it was. A drag jdtls edits nothing for, such as a text file, is no
refactoring, so it leaves the last one (and its own Undo Move) undoable. One drag at a time: a drop while one is
under way is refused with a message; drop again when it is done (an Undo Move then says to undo it when it is
done). A folder with no Java in it is not asked about. A Java package named build, out or target moves with its classes. jdtls is told about the destination folder first, a .java move it has no package edit
for says so (not when the destination is the same package, as from main to test), and while it is still loading
Editora asks once per drag before moving Java files plainly, naming them all. Folders an undo removes are reported
to it, and a moved folder is checked for Java files off the UI thread.
Java: no completion list after a rename or inline, or after undoing one. An applied edit opened the list at
the caret, and the next Enter took its first row.
Java: Smart Type binds a type variable by the method’s return type (names.toArray( into a String[] wants a
String[], not String[][]), leaves it open inside another call’s argument, and reads the parameter of every
overload (System.out.println( offers an int) at the argument the caret is in, also when no overload fits the
arguments before it; a type variable inside a parameter type is named (Collection<? extends String>); a bracket
inside a string, a char or a comment no longer hides the call.
Java: a JDK with its sources is preferred. Of two JDKs of one version jdtls gets the one with src.zip, even
when the other is the Default JDK or JAVA_HOME. A JDK with no sources at all (a distro JDK whose src.zip links
to an uninstalled package, such as Debian’s without openjdk-21-source) still gives JDK parameters as arg0.
Java: formatter profiles. The content-addressed copies are kept in a private folder of this process, checked
before use and removed when replaced, instead of a shared temporary folder; a server in a container or WSL gets
the project’s own profile; removing a profile (in this session or while Editora was closed), or editing one in
.settings or config outside Editora, applies without a restart, in a project window as in one without a
project, also when the folder comes with it (a checkout). The project’s code style now does follow .editorconfig and formatter-profile changes without one.
jdtls still writes its compiler settings into a .settings folder the project already has (an Eclipse project’s
committed org.eclipse.jdt.core.prefs); a project without one gets none.
Java: Add all missing imports asks which class an ambiguous name means, as Organize Imports does.
Complete Statement reads indentation: a line at the statement’s own indent is the next statement, a further
indented this.x goes on. A block that ends a declaration or a return closes with };, one in an if (…(x -> { condition
with })) {, and an annotation leaves the caret at its own indent.
Two Java projects in one window each get their own status line, named by folder, so one’s failed import is no
longer followed by the other’s “Loaded and ready”. A Maven project’s missing dependency is said once, at ready,
and a fixed pom.xml ends on ready.
Clearer menu rows, better Go to Class ranking and steadier pickers. Menu rows keep their prefix when two would
otherwise read the same (“Rerun Last” twice in Run, “Find in Files” in Find and Window). Go to Class puts
Map.Entry first for “Entry”, ranking shaded copies as nested types. Implementation rows are sorted by class and
line. Refactor This puts what acts on the selection before Extract Interface. Postfix completion rows match past the
shared qualifier, and the camel-hump matcher no longer slows down on long many-word texts. Settings no longer logs
an error after an install when its Mermaid page was never opened.
Java: a failed import names the real cause (a Gradle build’s “Could not find method …”, not the generic
“Could not fetch model”), and belongs to its own project: in a window of several projects one failed import no
longer marks the others, and it clears once that project imports.
Doctor’s Update no longer half-deletes an install that is in use. When another window or program still holds
the old jdtls open (on Windows), the update is refused with a reason and the old copy stays whole.
Java: dragging a .java file or package in the Project tree moves the class: its package line and the
imports of its users are updated, and Undo Move takes both back. It used to move the file only, and the project
stopped compiling.
Java: a file open in a tab the server has not opened yet (restored from the last session, or open across a
restart) is announced when you save it, so the next rename finds it.
Java: after a failed Gradle import, Reload Project Configuration imports again. It restarts the server
instead of updating a project that does not exist. A Maven project with an unresolved dependency is “loaded, but
the build has problems”, not “did not import”; Clean Java Workspace forgets the failure; run from a pom.xml or
build.gradle tab it starts the server again; and the reason no longer carries a stray ” PM”.
Java: “Initialize the field in” shows its choices translated, not as message keys.
Java: Inline Method is chosen from its list, not run by Ctrl+Alt+N alone, and an action the server cannot
apply says so.
Java: a loose package demo; file is rooted where its package says as it opens, not only after its text has
loaded: no wrong-package errors and no extra server per package folder.
Java: Smart Type completion fills a generic parameter (List.of(, Optional.of(, requireNonNull() from
the declaration’s type instead of offering only null.
Java: Go to Symbol ranks Map.Entry sensibly: nested library types sit below an exact top-level match, not
below everything, and “Map.Entry” finds it first.
Java: the implementation picker names each row’s line, and leaves out the excluded types.
Surround With is titled for what it does, Esc gives back the caret and selection, and a selection over
several lines wraps the lines it touches.
Complete Statement closes a call around a lambda block (});) and leaves a half-typed line where it is.
Doctor’s Update stops the server in every window while it replaces the install.
Smaller fixes: the rename and move preview fits its rows; the import chooser asks its question in its title;
Problems groups project problems under “Project”; the Hierarchy window’s count; status lines after a tree rename
and a Move; plurals in “the rename left 1 new error”; Portuguese terms.
Java: refactorings no longer leave the language server behind. A file a rename or move wrote without a tab
is announced to jdtls, so the next rename finds it; a file it creates is announced too.
Java: renaming or moving a file in the Project tree saves and undoes as one refactoring. The class is renamed
with its file, the files jdtls changed are saved, and Undo Last Refactoring moves it back.
Java: Move ▸ New package… creates the folder in the project, not at jdtls’s workspace path, and only main
source roots are offered for main code.
Java: Complete Statement leaves a wrapped statement whole (a stream chain, a ternary, arguments over several
lines) and closes a new block when the next } belongs to the enclosing one.
Java: Smart Type completion finds the type behind a qualifier (String s = user.), in a ternary branch and
at a varargs argument.
Java: the project’s code style follows .editorconfig and formatter-profile changes without a restart (an
edited profile is sent under a new name, which is what makes jdtls read it again), and the quiet
import chooser answers only for the document it was raised for. jdtls’s bundle reload no longer logs an error
on every start.
Java: Clean Java Workspace wins against another window’s restart, and a window joining a ready shared server
says it is ready.
Java: a failed import says why (jdtls’s logged reason, not a raw “(WARNING)”) and is not then called “Loaded
and ready”; project-level problems (in pom.xml or a Gradle build file) reach Problems when it lists only open
files; a plain-folder file is no longer red until reopened; the post-import build runs for Maven projects only.
Settings ▸ LSP no longer calls an outdated jdtls “Installed”. Its pill says it is older than the release
Editora is tested with, with Install… to update Editora’s copy, as Doctor’s Update… does.
Java navigation: a library class opened from Go to Symbol lands on its declaration, not its package line;
Structure no longer shows a method’s return type twice; implementation, type definition and declaration report
a failed request instead of “nothing found”; a refused rename or code action says the server’s reason.
Rename and move previews are as wide as their rows, show project-relative paths and where a moved file goes,
and say Enter applies.
Java editing:/** + Enter lines the closing */ up; one Undo reverts everything the actions on save did;
lambda type hints keep their space (String s ->); completion matches a method on its name, not its parameter
list; signature help shows the active parameter’s own description; “Initialize the field in” shows translated
choices; a second file opened while jdtls starts no longer says “Starting…” again.
Java: a folder of .java files with packages but no build file is no longer red everywhere. jdtls guessed
each file’s own folder as its source folder, so src/demo/Main.java declaring package demo was flagged as
being in the wrong package and nothing in it resolved. Editora now tells jdtls the source folder the package
declaration implies as soon as the file is open, the correction Debug already made at launch.
Java: whole-project Problems drops errors that were fixed. With Problems showing the whole project, saving
a Java file now runs a quiet incremental build, so errors in files that are not open clear once their cause is
fixed, instead of staying until Build Project was run again.
The quick-fix list puts the fix first. It listed jdtls’s actions in the server’s order, so “Extract
interface…” was preselected and the fix for the squiggle sat below ten generators. Fixes now come first, then
assists, refactorings and source actions; repeated titles are dropped, rows say “Fix”, “Refactor” or “Generate”
instead of LSP kind ids, and for Java the generators moved to Generate. Typing filters the list instead of
editing the code behind it, and the fixes for a line’s problem are offered from anywhere on that line, not
only with the caret on the squiggle.
Java: a refactoring that moves or creates files leaves the disk consistent. A class rename, Move or
Extract Interface changed files on disk but left their new text unsaved, so the project did not compile until
every tab was saved. Every file such a refactoring touches is now saved. A file the refactoring opened only to
change it is saved and its tab closed, instead of a dirty tab per file.
Java: a rename that clashes with an existing name is reported. jdtls applies it anyway; Editora now checks
the renamed files afterwards and says how many new errors it left and how to undo it.
Java: a pom.xml or build.gradle change reaches the classpath. jdtls asked “A build file was modified. Do you
want to synchronize the Java classpath/configuration?” in the status line, where it could not be answered, so a
dependency added to the pom stayed unresolved. Build files now sync on save (updateBuildConfiguration: automatic), and jdtls’s other questions come with buttons that run its answer.
Java: Organize Imports works when a name is ambiguous. With one Date or List that could be two classes it
did nothing and said “Imports already organized”. It now asks which class each such name means, and imports the
rest either way.
Java: paste with imports only imports what the pasted code uses. jdtls resolved every missing import of the
file, so pasting int z = 1; could add an unrelated import java.time.LocalDate;.
Java: Reload Project Configuration and Build Project work from the pom.xml tab, where they reached the pom
language server instead of jdtls. Build Project now says when the build found errors (“Project built with
errors: see Problems”) instead of “Project built”.
Java: opening a project no longer writes Eclipse files into it. jdtls put .project, .classpath and
.settings/ into every imported project and module, where they showed up in git status. They now stay in
jdtls’s own workspace (-Djava.import.generatesMetadataFilesAtProjectRoot=false, as vscode-java does). Files
written by earlier versions are not removed.
Java: Gradle projects import when a newer JDK is installed. The newest JDK on the machine became jdtls’s
default runtime, and Gradle ran on it; with JDK 27 installed every Gradle 9 import failed while the status bar
read “1100% Starting Java Language Server”. The default is now Settings ▸ Build Tools ▸ Default JDK, else
JAVA_HOME, else the newest, and Gradle is told to run on it.
Java: jdtls starts when JAVA_HOME points at a JDK older than 21. Editora now hands jdtls’s launcher a JDK
21 or newer that it finds (the Default JDK when it qualifies), and when there is none it says so instead of
reporting that the server “keeps crashing”.
Java: jdtls’s memory is capped. It started with -Xms1G and no limit, 1.3–2.5 GB for a small project; it now
gets vscode-java’s defaults (-Xmx2G, parallel GC, a small initial heap). A -Xmx or GC flag of your own on
the command or in JDK_JAVA_OPTIONS still wins.
Java: Gradle projects reach “Loaded and ready”, and the import narration makes sense. A Gradle import kept
sending “Starting” lines after jdtls said it was ready, which kept the ready line from ever coming.
Percentages past 100 (“1100% Starting Java Language Server”) are dropped, and a failed import (“WARNING”) is
reported as an error that says where to look. Opening another file into a server that is already running no
longer says “Starting Java language server…”.
Java: the completion documentation popup shows Javadoc. jdtls computes an item’s Javadoc in
completionItem/resolve only when the client lists documentation among the properties it resolves; Editora
listed only additionalTextEdits, so the popup showed the return type and nothing else.
Java: signature help shows the method’s Javadoc. The setting was sent as java.signatureHelp.description;
jdtls reads java.signatureHelp.description.enabled.
Java: completion and import quick fixes no longer offer JDK internals (sun.*, com.sun.*, jdk.*) or
java.awt.*. jdtls installs its type filter only when the client sends one; Editora now sends vscode-java’s list,
editable as Excluded types.
Java: inlay hints follow the “all arguments” mode and show inferred types. jdtls filtered parameter-name
hints to literals on its own, so the “all” mode changed nothing; it now sends every name and Editora’s filter
applies the mode. var declarations and lambda parameters get their inferred type, hints for numbered names
such as List.of(e1:, e2:) are dropped, and an unkinded hint without a trailing : or = (jdtls’s lambda
parameter type) counts as a type hint, which the literals mode never removes.
Java: quick fixes and generated members follow the file’s indentation. jdtls asks the client for
java.format.tabSize and insertSpaces before every code action and got no answer, so Generate toString,
Create method and the other generators indented with tabs in space-indented files.
Jumps no longer flicker, and their target is never hidden under the sticky-scroll rows. A click in the
Structure panel, Go to Line, a jump to a line from a bookmark, TODO or the Problems list, Go to Definition, a
search hit and the fold motions all repainted the editor over two or three frames: the caret moved before the
view, the view jumped before the pinned scope headers changed, and the minimap’s viewport box followed a frame
behind. Each now lands in one frame, and the minimap’s box keeps up with every scroll. In the Structure panel
the row clicked and the row left no longer flash unstyled black text. Go to Line and the fold motions put a
line above the view below the pinned headers instead of under them, a line already in view is not scrolled
to, and a jump to the line just inside a method no longer lands under that method’s own header.
Java: Go to Definition into library source lands on the declaration, shown below the sticky header, rather
than on the first line of its Javadoc, under the header; the status bar no longer stays on “Loading library source…” or reads “Editable”
for the read-only tab.
Java: Find References says when it failed or timed out (“the language server may still be indexing”) instead
of “No references found”.
Java: completion matches the name, not the parameters. Without a filter text from the server, items.st
offered addAll(Collection<? extends Item> c) and equals(Object o) because the parameter list was matched.
Opening Problems keeps the caret line in view. A bottom tool window opening scrolled the line being edited off
the screen.
Problems no longer shows jdtls’s numeric problem ids ([67108964]), which linked nowhere.
New Java files in Gradle source sets get the right package. In src/integrationTest/java or
src/testFixtures/java the source-set folders became part of the package name.
Java: a project’s JDK and compliance problems appear after it is imported. jdtls reports them on the project
folder, and only a build produced them: a project expecting Java 8 on a machine without one showed odd errors
and no reason until Build Project. One quiet build now follows each Maven or Gradle import, and such a problem is
said in the status line and listed in Problems in either scope.
The Run Configurations window reopens from the Run dropdown and fits its form. Picking Edit
Configurations… a second time did nothing when there were no configurations yet (the dropdown’s list stayed on
that row). The window now opens large enough for its form at a bigger desktop text scale, up to 90% of the
screen, and the form scrolls above a pinned Save / Close row when the window is shorter.