Eclipse SDK

What's new in this version:

New features in the Platform and Equinox:
Themes and Styling:
Improved Disabled Icons Generation:
Contributors:
- Up to now, disabled versions of icons usually were and had to be provided as explicit, separate image files. In case no such icon was provided, an algorithm in SWT was used to generate a disabled icon. However, that algorithm was very limited and produced poor results.
- The algorithm in SWT was now improved such that results are by default equal to the disabled version of the icons that have explicitly been provided for the Eclipse Platform bundles in the past. The pre-generated disabled icons have been replaced with the usage of on-the-fly generated disabled versions of the icons via the SWT algorithm. This includes in particular the removal of disabledIcon in plugin.xml files and programmatically setting the disabledImageDescriptor for Actions.
- In addition, the algorithm for the calculation of disabled versions of icons became configurable. The algorithm can changed via the system property org.eclipse.swt.image.disablement with the following options:
grayed (default): produces a gray-scaled version of the icon, which is aligned with the existing, pre-generated disabled versions of icons for Eclipse bundles desaturated (preview): produces a desaturated version of the icon, comparable to the grayed version but still keeping some color in it; the configuration of this option may be subject to change in future releases of Eclipse gtk: produces an icon version that conforms with the default disablement algorithm of GTK

Debug:
Custom Labels for Breakpoints:
- Managing breakpoints in large codebases just got easier. You can now assign custom labels to breakpoints in the Breakpoints view. When debugging complex applications, it's common to set numerous breakpoints. Identifying the important ones quickly can be time-consuming and error-prone.
- This new feature allows you to add meaningful labels to breakpoints so that you can locate, categorize, and prioritize them more effectively.
- To label a breakpoint, simply right-click on a breakpoint in the Breakpoints view and choose Label.

General Updates:
Explicit Minimum Windows Version:
- Currently, Eclipse officially supports Windows 10 and 11. By now, this was not validated explicitly but only defined as an implicit requirement. When using an unsupported Windows version, it could happen that startup of an Eclipse or plain SWT application failed with a linkage error because unavailable functions of more recent operating system versions are linked.
- SWT now validates the supported Windows version during application startup and fails with an according error message if the version is not supported. It is supposed to improve comprehensibility of the reason for initialization to fail by logging a better error message.
- The minimum Windows version is set to build 14393, which conforms to the original Window 10 and Windows Server 2016 releases. In case you are facing issues with the version check, it can be disabled with the system property swt.disableWindowsVersionCheck. Note that you may then face linkage errors instead.

Note: This validation is not part of the Eclipse update process, i.e., it will not prevent an existing Eclipse installation from being updated on an unsupported Windows version.

Monitor-Specific UI Scaling as Default (Windows only):
- In the previous releases, a preference to enable an improved, monitor- and resolution-specific UI scaling on Windows was introduced, see the news for 4.34 and 4.35 for details. The feature has been further improved since then and is now enabled by default.
- The feature makes each window adapt its scaling to the monitor it is currently placed on in a sharp, resolution-specific way and without requiring the application to restart. When using multiple windows, each of them will adapt its scaling to the monitor it is placed on. When enabled, this new feature replaces the current, limited scaling support for high-resolution monitors, which initializes the application's window according to the scaling of the primary monitor at application startup and produces blurry scaling when moving the window to another monitor unless the application is restarted.
- To disable this feature, uncheck the Monitor-specific UI scaling box on the Appearance preference page (Window > Preferences > General > Appearance), as shown in the image below. The feature is still under further development. We encourage users to share their feedback to help us improve the functionality.
- The images below demonstrate the scaling behavior in an extract of an Eclipse application when moving the window from a primary monitor with 100% scaling to another monitor with 200% scaling, first having the feature disabled and second having it enabled.

Support for SVG Images:
- Until now, Eclipse only supported loading of raster graphics. This limited the ability to scale icons without quality loss and required manual rasterization of SVG files outside to generate icons in different sizes that can be embedded in Eclipse products, leading to additional effort and many separate icon files.
- Support for vector graphics (SVG) has now been added. Instead of providing multiple rasterized images for different sizes, a single SVG file can be referenced. The SVG is rasterized on-the-fly at the required size when the image is retrieved at runtime. This ensures optimal image quality for arbitrary scaling factors without manual preprocessing. Support for loading raster graphics remains available. Together with the on-the-fly generation of disabled versions of icons, only one source file per icon needs to be managed for all required zoom levels as well as their visualization in enabled and disabled state.
- As part of this change, most icons across all Eclipse SDK bundles have been added as SVGs, and the corresponding paths (e.g., in plugin.xml files) have been updated accordingly.
- This improvement is especially beneficial for High-DPI displays, where crisp, scalable icons enhance the visual appearance and usability of the user interface. It also ensures better adaptation to different display settings and dynamic scaling scenarios.

DEPRECATION NOTE: The obsolete PNG files are now considered deprecated. They may be removed with Eclipse 2027-06.
- The following screenshots compare the use of raster graphics and vector graphics when loading icons with 125% monitor scaling.

New features for Java developers:
Java Editor:
Custom Folding Regions:
- It is now possible to create custom folding regions by specifying a comment at the start and end of the region. You can enable and configure this feature under Window > Preferences > Java > Editor > Folding > Custom folding regions
- on that preference page, you can specify the text that should be used to start and end a custom folding region. When this is enabled, writing a comment starting with the specified region start followed by another comment starting with the specified region end creates a folding region. Custom folding regions can be collapsed like any other folding regions

Project Properties Page for Folding:
- Preferences for folding can now be configured on a per-project basis in addition to configuring folding for the workspace. This page is available under Project > Properties > Java Editor > Folding.
- New Folding Mechanism as Default
- In the previous release, a preference to enable different kinds of folding was introduced, see the news for 4.35. The feature has been further improved since then and is now enabled by default.
- This feature enhances the code folding mechanism in Eclipse JDT by enabling folding for control statements such as if, while, switch, and for. It improves code readability and navigation by allowing developers to collapse and expand structured blocks.

Unnecessary SuppressWarnings Clean-up:
- A new clean-up has been added to remove unnecessary @SuppressWarnings tokens. To access the new clean-up, go to Source > Cleanups... > Configure and on the Unnecessary Code tab, select Remove unnecessary suppresswarnings tokens

Improved Pattern instanceof to Switch Clean-up:
- The Pattern instanceof to switch clean-up for Java 21 and higher has been improved and a number of errors have been fixed from the initial version released in 4.35. The Pattern instanceof clean-up is available via the Java Feature tab of the clean-up configuration dialog under the Java 21 group.
- The first improvement is that the clean-up now recognizes checks for null and will use any statements to generate the case null in the switch. A default clause will still be generated based on any else clause (possibly empty if no else clause exists).
- The second improvement is that in the case of a Pattern instanceof if statement that has no else clause, but is followed by a return or throws statement, these statements will be taken into consideration for whether a switch expression is possible.
- A third improvement is that if a pattern variable is not used by the code in the if statement and the Java version is 22 or higher, then the unnamed variable _ will be substituted in the case.

Inliner Improvements for Lambdas:
- The inline refactoring has been improved with regards to lambda expressions. In the past, only a simple return statement could be used to inline a method call inside a lambda expression body. This is now enhanced to include an empty method or multiple statement methods. Additionally, a lambda method reference is now recognized as a site for inlining a method. This is important in the case where the original method is being deleted.

Java Compiler:
- The compiler and the basic IDE support for the following JEPs are available

JEP 488: Primitive Types in Patterns, instanceof, and switch (Second Preview)
- Enhance pattern matching by allowing primitive types in all pattern contexts, and extend instanceof and switch to work with all primitive types.

JEP 492: Flexible Constructor Bodies (Third Preview)
- In constructors, allow statements to appear before an explicit constructor invocation, i.e., super(..) or this(..).

JEP 494: Module Import Declarations (Second Preview)
- Enhance the ability to succinctly import all of the packages exported by a module.

JEP 495: Simple Source Files and Instance Main Methods (Fourth Preview)
- Evolve the Java programming language so that beginners can write their first programs without needing to understand language features designed for large programs.

Debug:
Collapsing Stack Frames:
- Navigating in deep stack frames can be challenging during debuging, due to the high number of stack frames that are not relevant most of the time, for example because they are provided by either the JDK, by a testing framework, or by a library. This feature tries to help focus on the stack frames that are coming from the user-created projects, drastically reducing the unnecessary noise in the Debug View.

Navigate to Variable Declaration:
- Users can now navigate to a variable’s declaration directly from the Variables view during a debug session, making it easier to locate a variable, especially in methods with numerous local variables.

Auto-Resuming Trigger Points:
- Trigger points can now be configured to automatically resume execution when hit, allowing breakpoints after the trigger point to be activated while skipping those before it, thereby enabling a more focused and efficient debugging workflow.
- Upon enabling a trigger point, a new option will be shown to Continue execution on hit or not.
- Once Continue execution on hit is toggled, the breakpoint label will update to [Resume on hit] meaning it won't suspend on hit.
- Resume trigger also supports conditions, meaning if condition is true it will resume the execution otherwise it will suspend.
- Now when you run in debug mode, the trigger point won't hit, allowing you to skip previous breakpoints, and stop on the actual breakpoint on which you need to focus.
- For example, here Resume trigger was set on line number 7 and during debugging it hit on line number 8 by skipping all the previous breakpoints.

New APIs in the Platform and Equinox:
SWT Changes:
- Lazy Handle Generation for Images and Fonts (Windows only)
- When creating resources like image Image and Font, the necessary OS handles were previously created eagerly upon instantiation of the resource. On Windows, this behavior was changed for images and fonts. Handles are now generated upon first access. Until then, only the metadata to generate a handle is stored.
- This is particularly relevant on Windows because of the introduction of monitor-specific scaling. That requires all resources to be potentially available at different zooms at the same time, depending on the zooms of the monitors on which application windows are placed. The lazy loading is one contribution to mitigate an increasing number of OS handles while reducing unnecessary OS handle generation in general.
- More precisely, images now only store their data source (such as a file path or a data provider) upon instantiation. In case the image data of an image is retrieved (getImageData(zoom)), the data is loaded from the data source for the specified zoom, still without creating an OS handle for it. Once the handle is accessed for the first time (e.g., due to usage in a control or drawing via a GC), it is created.

Note: if for an image the image data or handles are retrieved for different zooms, they are all stored in a single Image instance. Multiple zooms do not require the creation of multiple Image instances.
- As Linux and MacOS do not support monitor-specific scaling and thus do not require resources at different zooms at the same time, the feature is currently only implemented for Windows.

New features for Plug-in developers:
Plug-in Development Environment - 4.36:
- New OSGi Resolution View
- The upcoming Eclipse 4.36 release brings improvements to OSGi development, notably through the integration of a new OSGi Resolution view. This feature, migrated from the Bndtools plugin, offers developers a powerful tool for analyzing and resolving bundle dependencies within their Eclipse IDE.
- What Is the OSGi Resolution View?
- The OSGi Resolution view is a tool designed to visualize the requirements and capabilities of OSGi bundles. It allows developers to inspect the dependencies of a selected bundle or a group of bundles, providing insights into what each bundle requires and what it offers. This is particularly useful for identifying and resolving issues related to unsatisfied requirements or conflicting capabilities.

Key features of the Resolution View include the following:
Side-by-Side Comparison: Displays the requirements and capabilities of selected bundles, facilitating a clear understanding of their dependencies.

Search Filters: Enables filtering of requirements and capabilities using wildcards and multiple search terms, streamlining the process of locating specific dependencies.

Optional Requirements Toggle: Allows developers to hide or display optional requirements, focusing on critical dependencies.

Split Package Detection: Identifies capabilities exported by multiple bundles with differing package content, helping to avoid potential conflicts.

Clipboard Copying: Facilitates easy sharing and documentation by allowing copying of requirements and capabilities to the clipboard.
- These features collectively enhance the developer's ability to manage complex OSGi dependencies, leading to more robust and maintainable applications.

Migration from Bndtools:
- Previously, the OSGi Resolution view was a core component of the Bndtools Eclipse plugin, an Eclipse-based toolset for OSGi development. With Eclipse 4.36, this functionality has been integrated directly into the Eclipse platform, streamlining the development process and reducing the need for external plugins.
- Contributor acknowledgements