We’ve just published a new EAP build of the upcoming IntelliJ IDEA 2019.3, which focuses heavily on improving the performance and overall quality of the IDE.
Now, when the major performance changes are included in the latest IntelliJ IDEA 2019.3 EAP build, we can tell you about the key changes in detail.
Faster startup
As soon as you launch the IDE, you’ll see one of its major performance improvements – much faster startup.
While we always strive to improve the IDE’s performance, since v2019.2 we have making special efforts to reduce startup times, and this release cycle continues this long-term effort of speeding up the startup time.
This upcoming major version v2019.3 reduces startup times even further by introducing substantial architectural changes to the IntelliJ Platform.
The first three phases – bootstrap, app initialization preparation, and app initialization – have been optimized significantly. The rest are not yet fully optimized, but they have been improved thanks to some platform-wide changes.
During the bootstrap and app initialization preparation phases, classes are loaded, the UI subsystem is initialized, and other low-level things happen. We have optimized some routines (e.g. font loading on macOS) or parallelized them, because not every activity has to be fully completed by the beginning of the next phase. Now such activities block the subsequent steps only when they must.
In an ideal world, the app initialization phase (including app component creation) should not even exist as everything should be queried on demand. But in real life, there are some heavy services – file indices, virtual file system, code styles, and so on. So now, instead of waiting sequentially for each one to load, the IntelliJ Platform provides service preloading with several policies (fully async or partially async). Some core services have already been updated to utilize this feature.
We’re happy that we’ve achieved some exceptional optimization results, but we are not done with boosting startup times yet! We have more major changes planned, so you may expect even faster startup with v2020.1.
Build Tools
When importing a large Gradle project, performance has been optimized to reduce the peak memory consumption.
As measured on the project https://github.com/apereo/cas
In addition, the IDE doesn’t freeze as you edit a POM.xml file, and can instantly display completion suggestions.
Version Control Systems
In the Version Control subsystem, we’ve managed to optimize the processing of events and the handling of ignored files. There will be fewer freezes and faster status updates in large projects. Better handling of ignored files has also been backported to v2019.2.3.
Java
We’ve invested a lot of effort into optimizing Java type inference, which helped us fix the various editor hangs. Also, Java type inference for long method call chains now works much faster.
Another improvement in this area is that code highlighting in Java files is now faster, especially when it comes to methods with generic var-args (Arrays.asList, Map.ofEntries, etc.) into which dozens of arguments are passed.
Other notable performance-related improvements include:
- Fixed performance issues when working with a large number of editor or debugger tabs.
- Greatly improved rendering of the project tree, especially when huge directories with thousands of files are displayed there.
- Resolved the IDE freezes in “Find in path” when the regular expression pattern matches very long strings.
- Improved performance of the Join Lines action when it’s invoked for many lines at once.
Eliminating UI freezes
We also continue to eliminate UI freezes, step by step. As you may know, with v2019.2 we introduced a straightforward way for you to report UI freezes for a comprehensive investigation – through the same dialog as the one used for reporting exceptions.
Up to this moment, we’ve received about 6,600 UI freeze reports and have fixed issues that were causing UI freezes affecting over 1600 reports.
We will definitely keep fixing UI freezes, so if you experience any of those, please report them to us. Bear in mind that the Early Access Program is a great time to submit such reports, as we still have time to fix some freezes before the release day, which is planned at the end of this fall.
Try it all out!
Give the new IntelliJ IDEA 2019.3 EAP build a try! Download it from our website or update via the Toolbox App. Patches for the in-product update will be available if you’re using the previous EAP build.
We hope you’ll enjoy all the improvements that are coming your way with the upcoming IntelliJ IDEA 2019.3. Check out our recent blog posts as well to learn about all the changes that v2019.3 is going to introduce.
We will greatly appreciate any and all feedback you can give us – here in the comments, in our issue tracker, or on Twitter. Thanks!
Happy Developing!
Keep up with great work!
One question: I’ve experienced relatively bad compile time performance on mixed kotlin / java projects with the latest stable version
Was there any effort made to improve it?
Thanks
I agree, we just tested out mixing in some Kotlin into our Java project. But due to performance issues that is currently a total no go. The usually so quick and responsive IntelliJ became like a sluggish and useless old monster.
Kotlin-related performance problems are worked on by the Kotlin team. They do invest effort into performance improvements, but the results of those efforts are announced on the Kotlin blog, not here.
Hope you will fix UI bugs too
https://youtrack.jetbrains.com/issue/IDEA-201369
Agreed. Please prioritize UI bugs.
https://youtrack.jetbrains.com/issue/WEB-40322 <- still an issue
https://youtrack.jetbrains.com/issue/IDEA-223157
https://youtrack.jetbrains.com/issue/IDEA-221157
https://youtrack.jetbrains.com/issue/WEB-40877
https://youtrack.jetbrains.com/issue/WEB-41408
https://youtrack.jetbrains.com/issue/IDEA-223794
The little things are starting to add up and drive me nuts.
Yes, the first one (disappearing cursor) is driving me crazy!!!
+1
+1
I keep pressing Ctrl-Tab after going into so tool window and closing it (eg. Cmd-1 or Cmd-9 twice).
It’s very reproducible and extremely annoying.
“Switcher” is about the 12th most used action on one of my machines according to the “Productivity Guide”.
On top of that I’m trying to convince my team mates to consider learning IntelliJ, so we can adopt Clojure easier and these kind of bugs make them look at me like “this is basic shit, isn’t it?” and they just go back to their tmux+vim/spacemacs/vs-code…
I hope long-standing issues like the XML editing performance will also be fixed (https://youtrack.jetbrains.com/issue/IDEA-88409).
I’m curious, will Java performance improvements somehow translate to improvements in Kotlin projects as well?
The particular improvements announced in this blog post are specific to Java and will not affect the performance of Kotlin projects.
Can we disable the new fast scrolling?
It’s laggy on my Mac and is driving me crazy
It’s possible to disable the smooth scrolling option. You’ll find the instruction in this ticket: https://youtrack.jetbrains.com/issue/IDEA-222656. Can you please share more details about the problems with the current implementation of the smooth scrolling feature. Thanks!
Yes, the new scrolling feels weird, and also a bit of laggy.
And I personally just don’t like it. Would be nice if we can disable it.
“Other notable performance-related improvements” seems to be ton in the right place, as they are in the “Java” subsection and have nothing to do with Java.
Feels like the paragraph was just wrongly placed.
The first time IDEA was opening eternally, the second time fast.
Very glad to read about these performance improvements, those of us who have to battle large legacy codebases need all the help we can get! Will some of these improvements be felt in Kotlin/mixed projects as well?
It crashes on start https://youtrack.jetbrains.com/issue/IDEA-223803
Kotlin-DSL gradle support needs a LOT of performance work. It’s a major performance issue, it’s a struggle every time I need to change my gradle files, ui locks up, typing doesn’t appear on screen, and then is written out all at once etc. 😐
Is that owned by the Kotlin Team or this team?
Hi! It is in our plan and we are working closely with Gradle to improve the situation. We already have some significant completion performance improvements for Kotlin 1.3.60 but it far from ideal. More improvements require changes both from Gradle, Kotlin and Idea side which is on the way.
I’m created tracking meta issue for these problems: https://youtrack.jetbrains.com/issue/KT-34440. Feel free to vote and watch.
My biggest concern at that point, which is not addressed here, is that the indexing in IntelliJ has taken a big performance hit for Kotlin projects. I have seen this ticket, but it’s not limited to problems with the new type inference algorithm. IntelliJ is painfully slow for me on large test files even after I disabled it.
https://youtrack.jetbrains.com/issue/KT-32158
Can you run some benchmarks and compare the performance of IDEA on a system using a SATA SSD, vs PCIE 4.0 SSD, vs Intel Optane? You know, for science and stuff.