Releases

IntelliJ IDEA 2019.3: Better Performance and Quality

Please give a warm welcome to IntelliJ IDEA 2019.3 – this year’s third and final major release of our flagship IDE!

With this major version of IntelliJ IDEA, we’ve focused on the performance and overall quality of the IDE. We held a quality-marathon, during which the IntelliJ IDEA team rallied together with several other JetBrains developer teams, to work specifically on polishing the IDE and make performance improvements, UI responsiveness fixes, usability enhancements, improvements in the existing functionality, and more.

To better define our priorities for this release cycle, we’ve been relying on your feedback even more than ever. We would like to say a massive thank you to everyone who has shared suggestions for improvements and reported issues to our tracker. During this release cycle, our team has managed to fix more than 1600 issues that together received a total of more than 3900 votes in our issue tracker.

We also had some ongoing projects in the works, things like support for new Microservices frameworks, e.g. Micronaut, Quarkus, and Helidon, and the long-awaited support for MongoDB.

We hope that these efforts make developing with IntelliJ IDEA even more enjoyable!

blog@2x (3)

Read further for more details.

Better performance

We’ve been working hard to improve the performance of IntelliJ IDEA and have achieved the following results:

  • Faster IDE startup
  • Overall better UI responsiveness, less UI and editor freezes
  • Reduced memory consumption, specifically on Gradle projects import

One of our main priorities for this year was to boost the start-up time. To achieve this goal we introduced a number of significant changes in IntelliJ-platform, we parallelized some of the processes that used to run sequentially, we reorganized the classes in a way that makes the initial class loading faster, we optimized the font loading on macOS, and much more.

Improving the UI responsiveness is another important area we’ve given a lot of our attention to. We have worked hard to resolve the UI freezes that occurred in various parts of IntelliJ IDEA, as nobody likes it when the user interface does not respond. We’ve made reporting UI freezes easier, and during this release cycle, we’ve been busy resolving the reports we have received (Thank you!). We were able to resolve a number of issues that were causing UI freezes in over 1600 reports.

Furthermore, IntelliJ IDEA doesn’t freeze when a regular expression pattern matches very long strings in “Find in path” or when working with a large number of editor or debugger tabs. The IDE now also renders the project tree faster.

We’ve also fixed various other editor freezes by investing a lot of effort into optimizing Java type inference. And speaking of Java performance improvements, the Java type inference for long method call chains now also works much faster. We’ve sped up code highlighting in Java files, especially when it comes to methods with generic var-args (Arrays.asList, Map.ofEntries, etc.) into which dozens of arguments are passed. The performance of the Join Lines action, when it’s invoked for many lines at once, has also improved.

We’ve bundled Kotlin plugin v1.3.60 with IntelliJ IDEA, which brings faster editor highlighting in Kotlin files too.

Performance optimizations have been made in the Version Control subsystem: we’ve managed to optimize the processing of events and the handling of ignored files. There are fewer freezes and faster status updates in large projects.

In the Build subsystem, we have managed to reduce the peak memory consumption on importing large Gradle projects. As for Maven projects, we’ve eliminated freezes when editing a pom.xml file, so the IDE now displays completion suggestions without any delay.

We’re happy with the results that we’ve been able to achieve, but we are not done yet! We plan to continue working on this, so you can expect even faster startup and more optimizations to come in the next releases.

Better quality of the existing features

IntelliJ IDEA has a rich plugin ecosystem, you have access to lots of incredible plugins through our plugin repository. However, the downside used to be that the managing plugins was a bit of a hassle, as the loading and unloading of plugins required restarting the IDE each time. Well, IntelliJ IDEA 2019.3 has addressed this issue by implementing core underlying infrastructure – support for dynamic plugin installation. This basically means that the IDE can now load and unload plugins without restarting. It is currently enabled for the theme and keymap plugins. With our future release, however, we plan to extend this to most plugins. This is one of the first steps to making plugin management as easy as possible.

A bunch of usability improvements have been made in the Version Control subsystem. To ensure clarity, we’ve improved the Git checkout workflow by removing “Checkout as action” and introducing 2 new separate actions instead: ‘New Branch from Selected’ and ‘Checkout’. The new ‘New Branch from Selected’ action creates a new branch and doesn’t set tracking. The ‘Checkout’ action silently creates a new local branch, checks it out, and sets tracking of the selected remote branch if there is no local branch with the same name.

To unify the UI for getting projects from different VCS hosting services, we’ve reworked the Clone dialog. Now you can log in from this dialog, or if you’re already logged in, the IDE will instantly preview lists of all repositories grouped by accounts or organizations.

Also, there is no need to check a branch out to push it, as there is now a straightforward way: simply find the needed branch in the Branches popup and push it. We’ve also added a file names column to the file history for renamed or moved files. One more improvement that you may find useful is the ability to force add a file to Git (or Mercurial) even if it is on the .gitignore (or .hgignore) list.

We introduced basic support for Java 13 in IntelliJ IDEA 2019.2, and with this release, we’ve significantly improved the support for Java13 Text Blocks. We recently published a blog post about these changes with more details.

A new Field Call Hierarchy action has been added. Simply use Ctrl+Alt+H (Windows, macOS, Linux), and you can view the hierarchy of a selected field. This makes everything much more straightforward.

Now, if you have the ‘Show quick documentation on mouse move’ checkbox enabled, hovering the mouse pointer over a warning or an error shows you a unified tooltip which displays the description of the warning or error and code reference information.
Previously, in such cases, the IDE displayed only the inspections tooltip instead of the documentation or sometimes it even showed 2 popups at once.

The default behavior of the intention action dialog was updated so that the intention actions will not disappear from the list of suggestions if you choose an intention action and then cancel the dialog.

The Services tool window is now always displayed and can be configured right inside itself. In addition to this, you can hide particular run configurations from this tool window.

Among other useful improvements:

  • The mismatched type tooltip was reworked to improve its readability.
  • On opening a project, IntelliJ IDEA now displays the project name.
  • Now, you can inject more template languages, specifically: Pug (ex-Jade), Handlebars, EJS, and Slim.
  • Scrolling with the mouse wheel is now smoother.
  • The scrollbar can now be made more visible thanks to the “Use contrast scrollbars” checkbox at Preferences/Settings | Appearance & Behavior | Appearance.

Support for new frameworks and technologies

Even though this release is quality-targeted, some notable features that have been in the works for a while are ready to be introduced. Please note that all the cool new things that we’ll talk about below are only available in IntelliJ IDEA Ultimate.

There had been a lot of buzz around microservices long before we started preparing for this release cycle. At some point, we thought that we could make the development process more pleasant and add support for the frameworks and technologies that are commonly used for developing Java and Kotlin projects with microservice-based architecture. Somehow, the stars aligned nicely for microservices in this release and we started working on integration.

Firstly, we added rich coding assistance and navigation for the new generation of microservices frameworks, namely: Micronaut, Quarkus, and Helidon. We also thought of those who use reactive web services on top of Spring and added support for Spring Web Flux.

Usually, microservices communicate with each over HTTP/ WebSocket, so the next step for us was to add support for the common Java HTTP client APIs such as java.net.URI / URL, Retrofit v2, OkHttp v3, as well as client libraries of popular server-side frameworks: Spring Feign, MicroProfile REST Client, etc. The great thing about this newly added support is that the IDE can now provide URL completion and navigation for HTTP/WebSocket APIs.

For the next stage, we thought we could give you a nice layout of the endpoints in your project, so we added a brand new ‘Endpoints’ tool window. This window displays the aggregated view of both client and server APIs. Gradually, this will become a central place for all your APIs, not only HTTP but also messaging, gRPC, and GraphQL.

Finally, we have added extended support for API documentation specifications. In this release, it was Swagger v2 and OpenAPI Specification v3. We hope that anyone who uses the specification-first approach in their work will enjoy having the support of validation by schema, code completion, navigation, find usages, and the rename refactoring in YAML/JSON files containing API descriptions in their IDE.

Pretty cool, right? For now, only Java and Kotlin projects are supported, but we have much bigger plans for this, and with our future release we will extend the support to more languages and frameworks.

On top of that, IntelliJ IDEA 2019.3 introduces the highly-anticipated MongoDB support. For now, it’s only initial support, but we are planning to enhance it in the future. IntelliJ IDEA now provides you with the ability to view collections and fields in the database explorer, run queries, and review query results.

Notable bug-fixes


We’ve been able to fix lots of issues, and here is a list of the most notable ones:

  • IntelliJ IDEA can now locate the directory to which Gradle has been installed when it has been installed through Homebrew.
  • It’s now easier to manually set the Gradle home directory.
  • The IDE now supports password storing via KWallet on Linux.
  • When you are working with a JavaFX project, the IDE can display an FXML file with the embedded Scene Builder in the Scene Builder tab.
  • Keyboard navigation in Debug tool window now works.
  • It’s now possible to copy a selected text from the inspection popup with Ctrl+C.
  • The focus isn’t lost when switching between the IDE windows.
  • Fixes for the windows and popup positions.
  • Invoked macOS windows are opened in dark theme when the Darcula theme is chosen in the IDE.

We’ve also updated JetBrains Runtime 11 (JBR 11) to integrate lots of fixes.

  • Fixed font rendering on macOS Catalina.
  • Fixed the issue with project opening on macOS 10.15 Catalina.
  • Repaired the symbols in the Evaluate Expression dialog.
  • The issue with fonts in the editor, which were always italic, was fixed.
  • Repaired the Welcome screen on Windows.
  • The IDE now warns about IDE keymap conflicts with native OS keymap.
  • Fixed the incorrect font (italic) in the editor.

Other changes

This release also includes all the changes from Android Studio 3.5.

We’ve also unbundled Vaadin and Java Applets support plugins. Those plugins will be available in our plugin repository and can be installed manually.

We tried a slightly different approach with this release, and we hope you like the results! If you would like to dive into the full list of addressed issues, here are the release notes.

Please let us know what you think! You can reach us on Twitter, Facebook, and by leaving a comment below.

Make sure to visit the What’s New page and watch an overview video.
Get IntelliJ IDEA 2019.3 and enjoy an even more stable version of your favorite Java IDE!

Happy Developing!

Discover more