What’s New in IntelliJ IDEA 2020.1

IntelliJ IDEA 2020.1 adds support for Java 14 and new features for a number of frameworks, upgrades the debugger with dataflow analysis assistance, adds a new LightEdit mode, downloads and configures the JDK for you, and does so much more!


Java 14 Support: Records & Pattern Matching

IntelliJ IDEA 2020.1 adds support for Java 14 and its new features. Not only does the IDE add full code insight support for Records, but it also enables you to quickly create new records and generate their constructors and components, and it warns about existing errors. You will also discover support for Pattern Matching for the instanceof operator including a new inspection and a quick-fix that quickly simplifies the verbose instanceof-and-cast idioms by replacing them with the new concise pattern variables.

More about using Java 14 with IntelliJ IDEA

Downloading JDK

Download the JDK from the IDE

You no longer need to search for the necessary JDK on the web. Starting with IntelliJ IDEA 2020.1, you can download and set up a JDK build right from the IDE as you create and configure your project. If you open a downloaded project, the IDE checks whether the JDK configured for this project is already installed on your computer. If not, the IDE will prompt you to download it.

New Java inspections

New Java inspections

With every new version of IntelliJ IDEA, we’re extending its static code analysis capabilities. And this release isn’t any different. Apart from a range of improvements, we’ve also added several new code inspections. They check capitalization in the SimpleDateFormat patterns, analyze date formatting cases, search for additional redundant method calls, and report and suggest eliminating unnecessary escaping characters in string literals.


LightEdit Mode

IntelliJ IDEA 2020.1 comes with the long-awaited LightEdit mode. You can now make quick modifications to standalone files in a text-like editor without creating or loading an entire project. You can open files in this new lightweight editor from the command line, the IDE’s Welcome screen, or from your OS system file manager. You can also switch from LightEdit mode to full project mode by using the “Open File in Project” intention (Alt+Enter).

More about LightEdit

In-place Rename and Change Signature

In-place Rename and Change Signature

When working on your Java or Kotlin app in IntelliJ IDEA 2020.1, you no longer need to use a cumbersome modal dialog to change the signature of a method or a class. Now you can simply edit the parameters of a class or a method, and then click the new gutter icon or press Alt+Enter to review and apply the changes to the class / method declaration and all of its usages.

More about In-place Rename and Change Signature

In-editor Javadocs rendering

Reading Javadocs in the editor can be annoying because of all the tags you have to wade through, especially when you need to interact with the reference links and images. This is why we’re adding a way to render Javadocs right in the editor. Enable this feature through Help | Find actions | Render documentation comments on file opening.

More about Javadocs rendering

Code Vision

We have taken our first steps toward implementing Code Vision – an easy way to focus on code while getting additional information about it. In IntelliJ IDEA 2020.1, Code Vision can show you the usages and implementations of Java symbols. To enable the feature, go toPreferences / Settings | Editor | Inlay Hints | Java, choose Code Vision, and check the related Show hints… checkboxes.

Improved navigation bar

Improved navigation bar

IntelliJ IDEA 2020.1 provides one more option to simplify project navigation. You can jump to the necessary line in a file straight away without scrolling because the navigation bar now shows you methods in Java classes and interfaces. If you don’t use the navigation bar, now is a great time to turn it on in View | Appearance | Navigation Bar.

Zen mode

Zen mode

We’ve introduced the new Zen Mode for our editor. It helps you eliminate any distractions and focus solely on your source code. Zen mode combines Distraction Free Mode with Full Screen Mode, so you don’t have to enable both of them anymore. Just select View | Appearance | Enter Zen Mode from the main menu and forget about the world outside.

Smart grammar checker

Smart Grammar and Spell Checker

IntelliJ IDEA 2020.1 comes bundled with the Grazie plugin, which is a comprehensive grammar, spelling, and style checking tool. Now the IDE checks more than just your code constructs. It also helps you write clear string literals, comments, Javadocs, commit messages, and much more in 16 natural languages. By default, it only checks text files, but we encourage you to enable it for Java files too in Settings/Preferences | Editor | Proofread | Grammar.

Quick type definition

Quick type definition

Learn the type definitions of variables, fields, methods, and other symbols without switching focus from your code. Place the caret at the necessary symbol and select View | Quick Type Definition from the main menu. IntelliJ IDEA then shows you the information in a popup, from which you can open the source file and edit the code.


Dataflow analysis assistance

Dataflow analysis assistance

IntelliJ IDEA 2020.1 adds dataflow analysis to the JVM debugger. It predicts code execution before this code is actually executed. When your application stops at a breakpoint, the IDE runs dataflow analysis based on the current state of the program to check what is going to happen next. To use DFA in the debugger, enable it in Settings/Preferences | Build, Execution, Deployment | Debugger | Data Views | Java.

Read Integrating Java Dataflow Analysis and the Debugger

Pin to top

Pin to top

Another improvement is the ability to pin any of an object’s fields to the top of the fields list. This is handy when an object has so many fields that it’s difficult to locate the one you need to investigate.


Focus on method calls

Focus on method calls Ultimate

Support for application profiling in IntelliJ IDEA keeps evolving. In this release, we’ve added several new features: Focus on Subtree, Focus on Call, Exclude Subtree, and Exclude Call. With these options, you can focus more specifically on a chosen method call and filter out the unnecessary ones.

Collapse recursive calls

Collapse recursive calls Ultimate

The profiler in IntelliJ IDEA now detects recursive calls when the same method is called higher up in the stack. The IDE allows you to bypass recursion by taking these calls out of the subtree, which lets you focus on the methods that consume most of the resources and on the calls that they make. Recursive calls are marked with this new special icon in the Call Tree tab of the Profiler tool window.

Initial support for HProf snapshots Ultimate

IntelliJ IDEA 2020.1 opens .hprof memory dump files that can help you identify memory leaks and find ways to optimize memory usage. For example, you will see basic information, like the total size, number of instances, and stack traces of the file. The files also list all root objects grouped by classes, all classes sorted by their numbers of instances or size, and all class instances with the field value viewer. To open the .hprof file, go to Help | Find action and type “hprof” to find the Open Hprof Snapshot action. Note that this feature is in its early stages, and will be improved in the following major releases.

Version Control

 New Commit tool window

New Commit tool window

In IntelliJ IDEA 2020.1, we’ve reworked the interface for committing changes to your VCS repository – instead of a modal Commit dialog, you can now take full advantage of the dedicated Commit tool window. It provides more space for the list of modified files and the diff, and it lets you add changes to a commit when they are ready, compose a commit message iteratively, and choose which of the staged changes go into which commit. The new UI is enabled by default for new users; existing users can switch to it in Preferences/Settings | Version Control | Commit.

New Interactively Rebase dialog

The reworked Interactively Rebase from Here dialog has become truly interactive. Now it does a lot more than letting you select an action you want to perform on each commit in your branch. It also features a graph showing which actions have been applied, displays commit details, and lets you see a diff and review or reset the changes if necessary.

Install Git from the IDE

Install Git from the IDE

With IntelliJ IDEA 2020.1, you no longer need to pre-install Git manually. When you clone an existing Git repository, the IDE will look for the Git executable on your machine, and will offer to download and set it up for you if the IDE can’t locate it.

Branches popup

  • The Branches popup now features an explicit search field that enables you to look for existing remote and local branches.
  • The Refresh button has been reworked, so that you can now use it to update the existing remote branches.
  • Incoming (blue) and outgoing (green) commit indicators have been added to the status bar.
  • The Log now features a branches list.


JetBrains Mono

JetBrains Mono

We care a lot about the efficiency of IntelliJ IDEA, but we also devote a great deal of our efforts to its look and feel. Many of our users already know that we’ve recently finished developing our own font – JetBrains Mono. We’ve been getting tons of positive feedback, and that is why JetBrains Mono has become the default font of IntelliJ IDEA in this release.

Unified IntelliJ Light theme

IntelliJ IDEA 2020.1 features a new default light theme that is now unified across all the different operating systems. Please welcome IntelliJ Light! You can always roll back to one of the old themes in View | Quick Switch Scheme | Theme, but we really encourage you to give IntelliJ Light a go.

Frameworks & Technologies

Spring WebFlux Ultimate

As we always strive to keep up with the developer trends and support the most popular technologies, in v2020.1 we’ve enhanced our support for the Spring WebFlux framework. We’ve added request mappings, so if your WebFlux application has Actuator enabled, you can access the mappings in the Run tool window to monitor your application and interact with it. Also, the IDE now works properly with the Rendering API, so code autocompletion and navigating to the related views are now available. On top of that, you can take full advantage of the code insight features, such as Find Usages (Alt+F7), and the Rename refactoring (Shift+F6).

More improvements for Spring WebFlux

Spring profiles Ultimate

Previously, IntelliJ IDEA treated Spring profile expressions as strings. Starting with v2020.1, the IDE distinguishes between different profiles in an expression, and lets you apply smart actions to them, such as Find Usages (Alt+F7) and the Rename refactoring (Shift+F6). We’ve also enhanced the usability of the Change Active Spring Profiles popup and implemented completion for existing profiles.


Selenium Ultimate

IntelliJ IDEA 2020.1 Ultimate introduces initial support for Selenium, a popular framework for testing web applications, through a new Selenium UI Automation Testing plugin. The new plugin supports the most popular JVM frameworks for UI testing and reporting libraries: Selenium, Selenide, Geb, Serenity BDD, and Allure Framework.


IntelliJ IDEA’s enhancements for Selenium include a new project wizard, highlighting, inspections, and code completion in tests for Java/Kotlin/Groovy languages, validation for various configuration files, and icons in the gutter for easier navigation.

More about Selenium Support in IntelliJ IDEA

JMS and Spring Messaging APIs Ultimate

IntelliJ IDEA 2020.1 comes with a full set of code insight features for JMS and Spring Messaging APIs for both Java and Kotlin applications. These include code completion, navigation, the Rename refactoring (Shift + F7), reference injection (Alt + Enter), and more.

Micronaut Ultimate

In the previous version of IntelliJ IDEA, we added support for the Micronaut framework. The new version extends this support and adds automatic completion for parameters in configuration files, as well as navigation and quick documentation. The IDE now also autocompletes basic data types and detects whether a value is invalid. Additionally, IntelliJ IDEA now recognizes injected RegExp fragments in Micronaut URL mappings, which makes the syntax more readable.

RxJava Ultimate

IntelliJ IDEA 2020.1 augments RxJava support by adding a number of useful inspections. The IDE now detects unused publishers, and lets you know when a lambda returns a null. It also highlights thread-blocking method calls and filter chains that are too long.

Project Generation for Quarkus and MicroProfile

Quarkus and MicroProfile Ultimate

With IntelliJ IDEA 2020.1, you can now create new Quarkus and MicroProfile projects directly through the New Project wizard, which will walk you through the initial configuration.

Language injections for third-party SQL libraries

Injections for third-party SQL libraries Ultimate

The IDE now automatically injects SQL fragments for popular third-party libraries that were previously treated as usual strings, and provides code completion and navigation for SQL statements and fields. The list of supported libraries includes R2DBC, Vert.x SQL Clients, Apache Spark SQL, and Apache DB Utils, among others.

Swagger Codegen

Swagger Codegen Ultimate

IntelliJ IDEA 2020.1 is integrated with Swagger Codegen – a powerful tool for generating server stubs, API clients, and documentation that supports a vast range of programming languages. We’ve prepared a dedicated run configuration where you can set things like a path to generate the files to, a path to the .mustache templates folder, a language, and a different JRE in case of compatibility issues. To let Swagger Codegen do its magic, you just need to open an OpenAPI/Swagger file, specify its settings, configure a few options, and then click Run.

Remote specifications Ultimate

IntelliJ IDEA 2020.1 knows how to work with openapi/swagger specifications. For example, it provides autocompletion for them. You just need to enter the specification URL in the settings, and the IDE will complete URL paths from it as you type. You can also create your own specifications in the same way that you usually create classes and interfaces: File | New | OpenAPI Specification.

HTTP Client

Improved autocompletion, and more Ultimate

The HTTP client in IntelliJ IDEA 2020.1 is getting a bit smarter. Now it can correctly autocomplete path variables and URL paths, and it can get you to the related endpoints right from the HTTP request files. We also have an update for our Micronaut and Spring users: request handler methods now feature a gutter icon for URL mappings. Use it to create or open an existing HTTP request file and navigate to the HTTP client.


Easier Pull workflow for Docker

Easier Pull workflow for Docker

To help you more easily pull images from a Docker registry, we’ve reworked our UI and removed the modal dialog. Now, you can simply click the Images node in the left-hand pane of the Service tool window, and IntelliJ IDEA will open the Images Console tab in the right-hand pane, from which you can easily pull images. The IDE also provides completion for images.


Apply command for Kubernetes files

“Apply” command for Kubernetes files Ultimate

You can now update a Kubernetes cluster to match a state defined in your local files, by invoking the “Apply” command right from the editor gutter.

More about Docker and Kubernetes improvements

Build tools

Maven and Gradle importing updates

Maven and Gradle importing updates

IntelliJ IDEA 2020.1 brings a small but important update to our Maven and Gradle users. Instead of the old auto-import, there’s now a floating notification in the upper-right part of the editor. Use this notification or a new shortcut (Ctrl+Shift+O for Windows and Linux /Shift+Cmd+I for Mac) to load the changes after you modify the build file. It gets even better: when IntelliJ IDEA detects any changes to the build file made outside the IDE, such as VCS updates, it reloads the related projects automatically.


Scala 3 support

Scala 3 support

Now that Dotty is destined to become Scala 3, we have started to work on full-fledged Scala 3 support. The Scala plugin now includes preliminary support for Scala 3, with the new syntax, error highlighting, navigation, type info, and many other bread-and-butter IDE features.

Because both the language and the language support are still works in progress, we recommend using nightly plugin builds if you want to get new features and bug fixes as soon as possible.

More about Scala 3 support in IntelliJ IDEA

Fine-grained error highlighting for function literals

Fine-grained error highlighting for function literals

In Scala, functional literals are used a lot. They are very much like methods and have separate parameters and bodies. But they are often treated as a single expression of function type, making it harder to locate and interpret errors.

In this release, we've introduced fine-grained error highlighting for function literals, which can help you pinpoint errors relying on clear and precise messages, instead of possibly obscure messages with function types.

Unused Parameter inspection

Unused Parameter inspection

The Scala plugin has been able to show unused variables and methods for a long time. Now it can also spot unused parameters. Parameters that are not referenced inside a method or class are highlighted in gray.

In contrast to variables and methods, unused parameters are often the result of programming errors. So not only does the new inspection make your code cleaner, but it can also help you prevent various errors.

Smart Step Into

Smart Step Into

In Scala, we often have multiple method calls on the same line. In such cases, using Step Into in the debugger is hardly convenient – you have to manually step into and then out of many methods before you reach the desired one.

In this release, Step Into has become Smart Step Into. You can simply choose a desired method, and the IDE will do the work.

BSP support improvements

We've improved BSP support. It now works more smoothly, and with more projects and build tools. You no longer have to manually install Bloop to import sbt projects via BSP – the Scala plugin can convert such projects to Bloop format automatically. It's now possible to cancel BSP builds from the Build tool window. Finally, you can view and manage BSP connections using the BSP widget.


New smart intentions and inspections

New smart intentions and inspections Ultimate

New smart intentions and inspections (Alt+Enter) enable you to save yourself some time when coding. For example, you can now quickly convert the existing code to optional chaining and/or nullish coalescing, the syntax introduced in the latest versions of JavaScript and TypeScript.

Vuex and Composition API support

Vuex and Composition API support Ultimate

With out-of-the-box support for the Vuex library and the Composition API from the upcoming Vue 3, you can build great Vue.js applications even more smoothly.

Take a look at What’s New in WebStorm to learn about the other JavaScript improvements that are also available in IntelliJ IDEA 2020.1.

Database improvements

Database improvements

Database improvements Ultimate

The database improvements include the ability to export data to Excel (.xlsx) files, view data as text right in the editor, create run configurations, and many other things.

Check out What’s New in DataGrip for all the database improvements that are also available in IntelliJ IDEA 2020.1.


Split terminal sessions

Split terminal sessions

We’ve added an ability to split terminal sessions vertically or horizontally so that you can run them side by side. You can invoke the context menu from the Terminal to create, navigate, and close a split terminal session.

Run Configurations

Store Run Configurations as files

Starting with v2020.1, you can choose any location within your project folder for your run configurations so that you can share them with your team members through version control. To do so, open the Run/Debug Configurations dialog, check Store as project file in the upper right part of the dialog, and click the gear icon. This will open a popup which allows you to choose where to store your run configurations.


Android Volley support

Android Volley support

IntelliJ IDEA 2020.1 brings support for the Android Volley library. It provides automatic code completion for URL path references, and lets you navigate to related resources.


  • IntelliJ-based IDEs have fully switched from JetBrains Runtime 8 (JBR8) to JetBrains Runtime 11 (JBR11).
  • IDE settings are now automatically imported from one major version to another.
  • The path to the IDE’s config files has changed.
  • Updated Find/Replace and Find in Path dialogs.
  • Unified SHH subsystem and configuration UI.