2017.3 Nov 30


Chain completion aware of type casts

Smart Completion is getting better with each release. In IntelliJ IDEA 2017.3, it is now aware of type casts and uses them to suggest chains of method calls.

Inference of nullability annotations for parameters

We’ve improved the way nullability annotations are inferred. Earlier, annotations were only inferred for library methods’ parameters and for any methods’ return types. Now we can also infer nullability annotations for the parameters of static, final and private methods.

Nullability checks for Stream API call chains

IntelliJ IDEA 2017.3 now detects possible nullability issues even in Stream API call chains.

Quick-fix to explicitly declare the inferred annotation

The IDE shows the inferred annotations in the Parameter Info and Quick Doc popups. When the caret is placed on such parameter, the IDE offers a quick-fix to explicitly declare the inferred annotation.

Support for JUnit5

IntelliJ IDEA 2017.3 provides inspections and quick-fixes to make it even easier for you to migrate your JUnit 4 tests to JUnit 5.

There is no need anymore to add additional dependencies as stated in JUnit 5 User Guide.

The following JARs will be downloaded automatically based on the API version used in the project:

  • org.junit.platform:junit-platform-launcher
  • org.junit.jupiter:junit-jupiter-engine
  • org.junit.vintage:junit-vintage-engine

Replacing StringBuilder with a Stream API call chain

StringBuilder can now be replaced with Stream.collect and Collectors.joining.

Invert boolean method quick-fix

IntelliJ IDEA detects different code inefficiencies, such as the Invert boolean method inspection. If a method was only used in an inverted way, it will be highlighted and a quick-fix will be suggested. In IntelliJ IDEA 2017.3, this inspection is performed on the fly.

Separate method calls on collections and Stream API call chains

Now, where it makes sense, the IDE suggests merging separate calls of the sort and toArray methods on collections with the Stream API call chains.

Detecting duplicate Map keys and Set elements

The IDE now detects duplicate Map keys and duplicated Set elements.

Detecting redundant throws declarations

Redundant throws declarations can now be detected on the fly.

Quick-fix for replacing deprecated code

The IDE now suggests a quick-fix for deprecated code if there is a replacement method in the JavaDoc.

Unroll loop

A new intention action unrolls a loop over an explicit list of values.

Run Dashboard supports any Run Configurations

The IDE now lets you add different types of run configurations to the Run Dashboard.

The Run Dashboard toolbar lets you rerun, stop, pause, or terminate an application. The right-hand side shows application-specific information.

Command line shortener

IntelliJ IDEA 2017.3 introduces a configurable command line shortener – a convenient new way to specify a method used to shorten the command line for each configuration.

You can set a default way to shorten the command line and use it as a template for your future configurations. IntelliJ IDEA 2017.3 also lets you share your configuration with your colleagues.

You can also preview the full command line if a long classpath was shortened via the temporary classpath.jar (the JAR Manifest option in the Run/Debug Configuration dialog).

learn more

JVM debugger

New Overhead tab

There’s a new Overhead tab in the Debugger tool window. It displays the overhead added either when stepping over the code or when the Data Renderers evaluate values to display them in Variables, Watches, or other places.

When it isn’t needed, the tab can be easily hidden and then restored again later.

On-demand Data Renderers

A new On-demand Data Renderers feature helps to reduce overhead. Now, the evaluation of values in Variables, Watches, and other places can be done on demand. Simply click on them when needed, instead of having them evaluated automatically.

Mute Renderers

To enable the On-Demand setting for the selected renderer, choose the Mute Renderers option from the context menu.

Improvements for Async Stacktraces

In IntelliJ IDEA 2017.3 the Async Stacktraces feature causes very low overhead and works out of the box, as the common capture points are built-in.

Java Stream Debugger

The Java Stream Debugger plugin, which visualizes the Java Stream operations, is built into IntelliJ IDEA 2017.3. The new functionality is available inside the Debugger tool window (click the Trace Current Stream Chain button). This plugin evaluates the current data stream and presents a visual representation of what exactly happens to each element, from the first call to the last.

Java EE 8

The long-awaited Java EE 8 is here, and it adds many new capabilities to the platform: Multiple CDI enhancements, including support for asynchronous events, HTTP/2 support in Servlet 4.0, and more. IntelliJ IDEA 2017.3 expands support for key features of Java EE 8. Learn more.

Asynchronous CDI Events

IntelliJ IDEA 2017.3 supports Asynchronous CDI Events allowing you to easily navigate between the position where the event was fired and where it was received.

Dynamic beans (CDI extensions)

In IntelliJ IDEA 2017.3, you can quickly navigate between the Injection point and Injected Beans using the icons in the gutter.

Navigation from disposer methods to their producers

You can navigate from disposer methods to their producers using an icon in the gutter.

HTTP/2 support for Servlet 4.0

One of the major features in Java EE 8 is HTTP/2 support for Servlet 4.0. HTTP/2 has an important new feature: Server push. It enables the server to send content to the client without an initial request from the client side. The main goal of this new approach is to improve the performance of web browsing. IntelliJ IDEA 2017.3 supports this new Server Push feature and offers path completion for the PushBuilder.


Neighborhood Mode in dependency diagrams.

The Spring Beans Dependencies diagram has been extended with a new Neighborhood Mode feature, which lets you choose only the necessary beans and view only their dependencies.

For better readability, you can easily switch to Borderless View.

Facetless auto-configuration

IntelliJ IDEA 2017.3 automatically detects a facet for Spring projects; for Spring MVC projects the IDE now detects both: the facet and the context.

Spring Boot

Auto-detection of MVC context

The long-awaited support for Spring Boot MVC web applications is already available in the IDE. With IntelliJ IDEA 2017.3, MVC context for Spring Boot MVC web applications is automatically detected. The IDE will automatically set up a Web Facet and a Spring Boot MVC Context.

Support for Spring Boot MVC web applications

IntelliJ IDEA 2017.3 makes all of its major features available when working with Spring Boot MVC web applications, including auto-completion, syntax highlighting, and navigation to related views.

Spring Boot 2.0 Actuator Endpoints

IntelliJ IDEA 2017.3 supports Spring Boot 2.0 Actuator Endpoints.

Highlighting for Spring Boot configuration files

In Spring Boot configuration files, the values are now highlighted according to their type.

Project configuration

Unloaded modules

When you update a project that has unloaded modules via a VCS, the IDE will analyze all the dependencies between the modules. If the newly added modules depend on existing ones, they will be marked as loaded; otherwise, as unloaded.

The IDE also checks whether unloaded modules compile successfully before a commit.

learn more


Coverage for Gradle

IntelliJ IDEA 2017.3 lets you run tests with coverage by using the Gradle Test Runner. You can even run tests with coverage if you select the Delegate IDE build/run action to Gradle option. Choose how you want to run your test with coverage from the main editor: with the platform test runner or with the Gradle Test Runner.

Build tool window

IntelliJ IDEA 2017.3 introduces a new Build tool window for Gradle build output. Previously, in some cases, Gradle build output was hidden in a background process, now it is displayed in the Build tool window. The output from the running task and test is shown in the Run and Debug window, as it was in IntelliJ IDEA 2017.2.

Editor-based REST client

Brand new editor-based REST client

IntelliJ IDEA 2017.3 introduces a brand new editor-based REST client. To start using the new REST client, create a scratch file with the .http extension. Use the icon on the left-hand panel of the editor to run a request. For easier navigation, the IDE will add a link to the request results.

Environment variables

In the new editor-based REST client, you can define the context for executing a request. Create a rest-client.env.json file inside your project and define an environment with variables. Once the environment variables are defined, you can easily switch between different environments such as production, testing, and development.


The Kotlin plugin bundled with the IDE has been updated to Kotlin 1.2. Now support for the experimental Kotlin multiplatform projects is available inside the IDE. This new Kotlin feature makes it possible to reuse code between target platforms supported by Kotlin, which are JVM, JavaScript, and (in the future) Kotlin/Native. Learn more.

Detecting expected declarations without the actual implementation

To call platform-specific code from a common module, you can specify expected declarations – declarations for which all platform-specific modules need to provide actual implementations.

Expected declarations should have actual implementation in the platform-specific module. If you try to use an expected declaration without the actual implementation, IntelliJ IDEA 2017.3 will detect the problem and alert you.

Intention action to create the actual class

The Kotlin plugin provides an intention action to create an actual implementation for missing declaration for JS and JVM platforms.

Navigation from expected declarations to actual implementations

For the multiplatform project feature, the IDE provides a gutter icon to let you easily navigate between expected declarations and actual implementations.

Version control

Interactively Rebase from Here in Log

Git integration in IntelliJ IDEA allows you to edit your project history by performing Interactive rebase before you apply changes from one branch to another. To make it even easier to use, starting with IntelliJ IDEA 2017.3 you can invoke it right from the Log tab of the Version Control tool window. To edit several commits in the current branch, select the oldest commit in the series and choose the Interactively Rebase from Here action from the context menu.

Preserving workspace when switching between branches

In IntelliJ IDEA 2017.3, Git integration supports working with multiple branches. When you switch between branches, the IDE preserves your workspace: the opened files, the current run configuration, and the breakpoints. The workspace associated with a branch will be automatically restored when you switch back to that branch.

Improvements for Git and Mercurial merge commits

Starting with this update, the IDE shows files changed by merge commits, even if they only differ from one parent. Previously only the files that had merge conflicts were displayed.

Furthermore, the IDE now displays a 3-panel Diff for merge conflicts.

Suggesting author and commit details for changes from patches

IntelliJ IDEA 2017.3 now reads the author and commit details provided by git format patches, so you don’t need to enter them manually when committing patches from the IDE.

Rename shelved changes

Changelists can now be renamed on the Shelf tab. Drag a changelist from the Local Changes tab to the Shelf tab, freeze for a second, and the Shelf tab will be activated allowing you to specify a new name for the shelved changelist.

Unshelve changes with drag’n’drop

Drag-and-drop a changelist from the Shelf tab to the Local Changes tab, and select a changelist to put it into.

Database tools

Grouping Data Sources

IntelliJ IDEA 20173.3 includes a new database tools feature: the ability to group data sources. Press F6 or choose Move to group… from the context menu.

Foreign Data Wrappers in PostgreSQL

Foreign Data Wrappers, and as a consequence, foreign tables, are now displayed in PostgreSQL.

Select schema & data source on running a file

IntelliJ IDEA 2017.3 now prompts you to choose a database/schema along with a datasource when you try to run an SQL file from the Project tool window.

Jump to Console from Data Source

For easier navigation, we’ve upgraded the context menu for datasources in the Database tool. Choose Jump to Console, and you’ll now have a handy menu for quickly switching between your consoles.

XQuery and XPath coding assistance

The XQuery/XPath support for Microsoft SQL Server is now provided through the Injected Languages feature.

Right-side alignment for numeric data

For better readability, the IDE now right-aligns numerical columns data in the data editor.

Synchronize IDE settings across devices

IntelliJ IDEA 2017.3 ensures better synchronization of your settings across different installations. It provides a more convenient method for storing your settings, utilizing a JetBrains repository to store items such as the UI theme, colors, fonts settings, and so on. You can apply these settings to all of your IDE instances using your JetBrains Account (JBA).

You can also synchronize the list of installed, enabled, and disabled plugins.

learn more


Highlighting of implicit usages

The Scala plugin now detects and highlights usages of a symbol in the current file even when it is used implicitly.

Build, Run, and Test processes do not depend on indexing anymore

For Scala integration, building or test execution processes shouldn’t require indexing, but this was not completely true until now. Previously, a number of dependencies forced you to wait until the IDE finished indexing. With this release, we’ve completely changed the logic, so you now you can run your existing run_configurations (application, tests …) in parallel with indexing. It’s especially useful for big projects where indexing takes considerable time.

Automatic SBT library import

Now the IDE suggests importing SBT libraries from the local Ivy cache.

Ammonite scripts support

The Scala plugin 2017.3 also provides support for Ammonite scripts. We’ve added:

  • Proper highlighting and navigation that respects the ammonite syntax
  • Run configuration with a gutter icon for launching scripts
  • Ammonite annotations
  • An action to import of {code}$ivy.{code} dependencies. This may be required for accurate resolution in the Editor.

A new wizard for Lightbend Tech Hub templates

As you may already know, Lightbend Activator was EOL-ed on May 24, 2017. It was replaced with the new technology: a "project starter" service. Following these changes, the Scala plugin has introduced a new Lightbend Project Starter wizard.


New UI for Run/Debug Configurations dialog

The Docker Run/Debug Configurations has been split into 3 different types: Docker Image, Dockerfile, and Docker-compose. The dialogs for these three types have been totally redesigned.

For Docker Image and Dockerfile run configurations in the Create Docker Configuration dialog, it’s now possible to accept the CLI arguments directly, without converting the docker run command into a JSON file.

With the Docker plugin, in addition to using environment variables for Dockerfile and Docker Image, you can also set files with environment variables in the container during a docker build.

Build Image action

A new Build Image action was added to the gutter for Dockerfile.

Custom names for Dockerfile and docker-compose files

The Docker plugin now supports Dockerfiles and docker-compose files with custom names and paths.

User Interface

Multiple soft limits

IntelliJ IDEA now allows you to сonfigure several visual guides to help control code width. The possibility to add multiple soft limits is now available in Settings/Preferences | Editor | Code Style.

Preview for SVG files

IntelliJ IDEA 2017.3 introduces a new Preview panel for the SVG editor. Observe the changes in the Preview panel while editing an SVG file in the editor.

2017.2 Jul 18


Smart completion

Chain Completion, which was available on the second call of Smart Completion, gets even better. Now the suggestions are displayed after the first call of Smart Completion, and they’re sorted by how frequently they’re used in the project. This feature works only for Java and requires the project to be built with the IDE’s (not Gradle’s) compiler.

Smart Completion is now aware of builder classes in the project and suggests their usage where relevant.

Control flow analysis

Control flow analysis has become much smarter and now detects a wider variety of problems in the code.

For example, if Collection#isEmpty() returns true, the IDE understands that there are no elements in that collection to iterate over.

The IDE also understands that String#charAt(int index) throws an exception when called with an empty string, or when the index exceeds the value returned by the String#length() method.

The same intelligence applies to: String#isEmpty(), String#charAt(int index), List#get(int index), Set#contains(Object item), Map#containsKey(Object key), Map#containsValue(Object value), and many other methods.

The IDE also gains a better understanding of reporting nullability issues, in particular when it comes to working with Collection and Map type parameters.

Java 9 module diagrams

Embracing Java 9 and its new module system, the preview introduces Module Diagrams. Use them to see the dependencies between the selected modules. To see the diagram, invoke Diagrams | Show Diagram (Ctrl+Alt+Shift+U), and then choose Java Modules Diagram.

The diagram works for JRE modules as well.

Refactoring to Java 9

The IDE finds the code where you construct sets and pre-fill them with data, and suggests replacing it with Set#of(String…items) where possible.

The IDE finds the loops spinning on a volatile field and suggests calling Thread#onSpinWait() inside such a loop. This call may significantly improve the performance of your code.

Extracting an expression as a map operation

Now, when you call Extract Variable inside a Stream API map call, the IDE offers to extract it as a separate map() expression.

Extracting a functional variable

Embracing Java 8 in one of the earlier releases, we introduced Extract Functional Parameter. With this preview, we’re going further and introducing Extract Functional Variable.

Extracting a lambda to a method reference

IntelliJ IDEA now offers you a quick-fix that replaces a lambda expression with a method reference. This combines Extract Method and Replace Lambda with Method Reference.

Replacing multiple equals with Set.contains

When you are checking whether an expression is equal to one of several literals, the IDE now offers you to replace these checks with a Set#contains(Object key) call.

JUnit 5 M4: parameterized and repeated tests

Following the recent JUnit 5 changes, the IDE adds dedicated coding assistance for Parameterized Tests and Repeated Tests.

Reflection API

Coding assistance for Reflection has gotten better. Also, we’ve introduced similar coding assistance for Method Handlers and Variable Handlers.

IntelliJ IDEA provides code completion for method and field names as well as their signatures.

JVM debugger

Filtering arrays & collections

The debugger now allows you to filter arrays and collections in Variables, Watches, Evaluate Expression and other similar views.

Java Stream Debugger

Out of the release scope, but you may also find it interesting to know that recently we introduced a new plugin called Java Stream Debugger. This plugin provides visualization of Java Stream operations.

You can use the plugin if you’re running IntelliJ IDEA 2017.1 or newer.

Spring Boot

Run Dashboard

For Spring Boot applications, the traditional Run tool window has been replaced with Run Dashboard. This dashboard lets you manage Run configurations and see their application-specific information on the right.

Actuator endpoints

For Spring Boot applications, the Run/Debug tool window now has a tab called Endpoints. This tab shows information about the Health, Beans, and Mappings endpoints.


Progress indicator

When Gradle is downloading a wrapper distributive, the IDE now displays the progress bar in both the Console tool window and the Background Tasks popup.

Environment variables

When you run a Gradle task via a Run Configuration, you can now specify and/or override environment variables.

On macOS, the Gradle build is now consistent with the command line behavior because the IDE now respects environment variables defined on the system level.

Kotlin 1.1.3

Semantic highlighting

Now, if you enable Semantic highlighting in the Colors & Fonts settings, the IDE highlights the definitions and all occurrences of local variable, and parameter with a distinct color.

TODO highlighting

The usages of the TODO() method are now highlighted in the editor as TODOs and shown in the TODO tool window.

Parameter names

To make the code even more readable, the editor now shows hints for the parameter names in method calls where the meaning of the arguments may not be clear from the context.

Type hints

Similarly to Parameter Hints, the editor now is capable of showing inferred types for the variables, functions, and parameters. This functionality is disabled by default; you can enable it in the editor appearance settings.

Groovy 2.5.0

The update brings the support for the new features introduced with Groovy 2.5.0: @groovy.transform.builder.Builder#includeSuperProperties, @groovy.transform.AutoImplement, and @groovy.lang.Delegate for methods


Debugging in SBT Shell

Earlier this year we introduced SBT Shell to make the work with SBT projects more convenient. Now, you can easily attach a Debugger to it with just one click.

Play 2.6 support

The support for Play Framework has been updated according to its latest version.

Implicits management

The Type Annotations inspection has been improved with implicit declarations processing. Any implicit is worth being explicitly annotated. It significantly increases the performance of compilation and IDE code analysis. It reduces the risk of a type inconsistency.

Completion for implicits

Now, if you call Smart Completion for following types: akka.actor.ActorRef, scala.concurrent.Future, it also suggests implicit conversions, and adds import statements automatically.

Version control

Reverting and rewording commits

The Git Log now provides two new actions: Revert and Reword. The first one lets you revert selected commits.

The second one lets you change the commit message for any commits that have not been pushed yet.

Formatting commit messages

The settings related to the Commit dialog have been reworked and moved to a separate page called Commit Dialog.

The new settings let you customize the rules applied to commit messages: a blank line between the subject and the body, and the maximum length. Also, now the IDE offers a quick fix and the Reformat action inside Commit Message.


The Shelf tab has been reworked for better performance and ergonomics.

The Show Diff action now by default compares the shelved version to the base version instead of local (when possible). The old behaviour, which is comparing to the local version, is available via the Compare with Local action (listed in the context menu).

The raw patch content can be viewed in the Preview tab.

User interface

Find in Path

The Preview panel in Find in Path now has a Gutter (a left-hand pane like that in the editor) with line numbers, navigation icons, and local change markers.

Search results from the same lines are now merged together.

A small icon indicates when a search is in progress.

Window 10 native UI

The appearance of certain UI elements on Windows 10 has been updated to follow the system look and feel. This includes buttons, radio buttons, checkboxes, text fields, select controls, spinner and a few others.

Better HiDPI support

The IDE used to scale its UI based on the global settings of the primary display. This scale factor was applied even to non-primary monitors. Now it scales its UI based on the scale factor for the monitor the UI is shown on. This improvement has a limitation: it works only for Windows and doesn’t support fractional values.

The font settings are now automatically adjusted based on the display resolution.

JavaScript & TypeScript

Parameter hints and type info

Parameter hints make the code easier to read by showing parameter names in method and function calls. Now, you can also now see the inferred type for objects by hovering over them with the mouse and holding Ctrl.

Code arrangement

The new Arrangement code style options allow you to configure how different blocks of code such as the constructor, fields and methods are ordered in your JavaScript and TypeScript classes. Call the Rearrange Code action or use it together with Reformat Code to make the code more readable and consistent.

Import code style from .eslintrc

You can now import some of the ESLint code style rules to the IDE’s JavaScript code style settings. Reply Yes when prompted about this in the .eslintrc file – that will apply the matched rules and make the IDE formatting more consistent with your ESLint configuration.

Move symbol refactoring

With the new Move Symbol refactoring you can now safely move classes, global functions or variables across ES6 modules – all the imports and exports will be updated automatically.

CSS modules

Using CSS Modules? Now when you’ve imported a CSS Module in your JavaScript file, you will get code completion and navigation to the definition for the class names in that module.

Angular Material

Support for Angular Material improvement: you can now use code completion and navigation for the Material attributes in addition to completion, for the components that were available before.


Coding assistance in JavaScript files now respects the webpack module resolution. Now when you’re using a complex webpack configuration with aliases and multiple modules, the IDE properly resolves the paths in import statements and suggest symbols to import.

Code coverage for Mocha

Run Mocha tests with coverage and see the coverage reports created by Istanbul right in the IDE. The report shows how many files were covered with tests and the percentage of covered lines in them. From it, you can jump to the file and see what lines were and were not covered.


Unloading modules

The preview brings a new experimental feature called Unloaded Modules. This feature gives you the ability to select which modules you are going to work on in your project. Those you are not working with at the moment are marked as Unloaded. The IDE will not index or otherwise touch any files in Unloaded Modules. This helps conserve CPU and memory resources when dealing with large codebases.

To access the feature, invoke the Project tree context menu and select Load/Unload Modules.

Then, if you’re are looking for usages of a symbol, or are about to refactor something, the IDE will warn that there are unloaded modules that depend on the modules you are working with, and therefore might contain code that should have been affected by the action, but won’t be.

Excluding files by pattern

To remove irrelevant files from search results and also improve indexing performance, now it's possible to specify a set of filename patterns to be excluded from indexing.

Pausing indexing

The indexing process now can be paused, e.g. if you need your CPU power for an urgent task.

2017.1 Mar 21


Java 9

The update brings support for the upcoming Java 9 and its new module system. The IDE supports the latest versions of JDK, helps import projects, and offers coding assistance when editing module declarations.

A built-in inspection validates module declarations and provides a quick-fix to adjust the project dependencies accordingly when necessary.

learn more

Java 8

The quick-fixes introduced earlier, which help migrate for loops to Stream API calls, have been improved and now support more complicated cases. We’ve also introduced a quick-fix that can migrate Stream API calls back into for loops.

When possible, the IDE suggests replacing Map.put statements and updating a value associated with a given key with a call of Map.merge.

Also, the IDE suggests replacing certain Map operations with Map.getOrDefault.

JUnit 5 inspections

All JUnit 4 inspections are now available for JUnit 5.

Regexp syntax highlighting

Dedicated section in SettingsEditorColors & Fonts for RegExp syntax highlighting.

JVM debugger

Async stacktraces

The new feature called Capture alters the stacktrace by substituting its parts related to asynchronous code execution with the corresponding parts of the stacktrace captured from where the asynchronous code is passed.

learn more

Stepping into async code

The Smart Step Into action now also supports asynchronous code and steps into lambda expressions executed on other threads.

Drag a breakpoint to remove it

We’ve added a new option called Drag a breakpoint to the editor area to remove it (available in SettingsBuild, Execution, DeploymentDebugger, disabled by default). If you enable the option, a click on a breakpoint, instead of removing it, will enable/disable it. This option may saves you from accidentally removing a breakpoint and losing its parameters such as a condition.

Memory view in Debug

The JVM Debugger Memory View, introduced with IntelliJ IDEA 2016.3 as a separate plugin is bundled and available inside the Debug tool window.

Emulated method breakpoints

Method breakpoints are now emulated by the IDE as a combination of regular line breakpoints. As a result, we have method breakpoints that are a little slower to set but do not slow down application performance.

Version control

More display and search options in Log

Now you can choose whether you want to use regular expressions and case sensitivity when searching over commit messages.

Also, you can choose how much information about branches and tags the Log viewer displays.

Ignore imports and formatting in Diff

The Diff dialog got a new option called Ignore imports and formatting. As its name says, it ignores changes within import statements and whitespaces (at the same time it respects whitespaces within String literals)

File history: performance and branches

The File History feature for Git has become faster. Besides better performance, it now can display the revisions graph, and even has a button to include changes from branches other than the current.

Branches popup: favorites and speed search

Now you can mark any branch as a favorite, for easier access.

The new popup also provides better search

User interface

Find in Path

The Find in Path dialog, which had received a Preview tab earlier, has been reworked from the ground up and now shows instant results in the first place

Emoji in Editor

The editor now supports Unicode emoji characters (which are sometimes used in comments and String literals). On Mac OS X, emoji characters are rendered as colored images, while on Windows and Linux, emoji are rendered as monochrome characters


Spring Data

Support for Spring Data has been also updated following the changes introduced with Spring Data 2.0. The improvements include support for many new annotations and types (reactive types), new inspections, code completion, navigation, and other coding assistance features.

The Spring tool window now has a new tab called “Data” to help you quickly navigate through the repositories defined in your project.

learn more

Spring Testing

Support for Spring Testing has been updated based on the changes introduced with Spring Boot 1.4.3 and the upcoming Spring 5.0 (test runners and inspections).

Spring MVC

Support for Spring MVC has been updated with coding assistance for path attribute in JSP form tags.


The Kotlin plugin bundled with the IDE has been updated to Kotlin 1.1, which enables the use of the language in many new scenarios.

JavaScript support

JavaScript target is no longer experimental, and supports all Kotlin language features, a large part of the standard library, as well as JavaScript interoperability. This allows you to migrate the browser frontend of your applications to Kotlin, while continuing to use modern JavaScript development frameworks such as React.


As a lightweight alternative to threads, coroutines enable much more scalable application backends, supporting massive workloads on a single JVM instance. In addition to that, coroutines are a very expressive tool for implementing asynchronous behavior, which is important for building responsive user interfaces on all platforms.



Coding assistance for Akka gets several new features:

  • Find Usages is now aware of the differences between Ask and Send usage types.
  • Warnings are fired for Actor's factory method arguments that aren't consistent with defined Actor's constructors.
  • The new action helps to auto-generate factory methods for an Actor companion object at the caret.


SBT tool window now lets you to easily run SBT tasks and has a button that opens SBT Shell tool window where you can use code completion to type and run SBT commands.

You can now delegate your IDE Build process to SBT. The option is still experimental and should be manually enabled via Build, Execution, DeploymentBuild ToolsSBTUse SBT shell for build and import

Last, but not least, Run Configurations for tests now offer two new options: Use sbt (delegates the Run process to SBT) and Use UI with sbt (uses the IDE's Test Runner UI, WIP).

Project Wizard

The Project Wizard has been reworked for better user experience and now offers the SBT project as the default option. Settings dialog for SBT projects has been also simplified.

Dotty become a subtype of the Scala SDK and now can be selected with both the SBT and IDEA project templates.

Worksheet REPL mode

The Worksheet editor has been extended with the REPL mode (WIP), that simulates REPL and executes only the newly appended lines of code, which results in better performance because the unchanged code is not compiled or evaluated.



Composite Builds

Support for Composite Builds, introduced earlier, has been greatly improved. Now the IDE automatically detects “includeBuild” in Gradle settings and configures the project accordingly. No manual configuration is required

learn more

Logback and Parameter Hints

This update brings coding assistance for editing Logback appender configurations. It includes code completion, finding usages, navigation and renaming.

The Parameter Hints option, which was added for Java in IntelliJ IDEA 2016.3, is now available for Groovy as well.



We've published a plugin that adds first-class support for Vue.js. The IDE not only understands the template, script and style blocks with various lang attributes in the .vue files, but also provides completion for Vue directives and component names.

Auto import for React components

Select a component defined in your application in the completion popup – and the IDE will add an import for it automatically. Forgot to import React? IntelliJ IDEA will provide a quick-fix.

New ES6 quick-fixes

The IDE now helps you convert for..in loops on arrays to for..of statements introduced in ECMAScript 6. All you have to do is press Alt+Enter on the loop and select this conversion option. Another new intention can convert iterations with forEach to for..of.

Sorting imports by module

The Optimize imports action can now automatically sort JavaScript and TypeScript imports alphabetically by module and reorder the imported members. You can configure this behavior in the Code Style settings.

Angular language service

To help you work with Angular even more, the IDE adds support for the Angular language service, developed by the Angular team to improve code analysis and completion for Angular-TypeScript projects.

Run npm install @angular/language-service --save-dev to enable that in your project.

Improved TSLint support

Integration with TSLint adds support for TSLint-powered quick-fixes. You can also import some of the code style rules defined in tslint.json to the IDE code style settings – just reply ‘Yes’ when prompted about this in the tslint.json file.

Better testing experience

Running Mocha and Jest tests is even easier now with the new Run icon on the gutter. Click the icon next to the test or the suit name and select Run or Debug.

The test status will be displayed next to the test name for all supported test frameworks.

Completion in package.json

Adding new project dependencies to package.json became easier: the IDE now provides code completion for package names.

The IDE also suggests the latest versions of the packages.

Support for Standard code style

The Code Style settings now support JavaScript Standard Style. To use it, go to SettingsEditorCode StyleJavaScript and click Set from Predefined Style – Standard.

Module dependency diagram

To overview the application structure, you can now visualize the module dependencies that a file, group of files or folder has. Right-click on a file or directory in the Project view or in the editor, and then select DiagramsShow diagram.

New code style options

This update brings lots of new code style options for JavaScript and TypeScript. You can now configure the use of semicolons to terminate statements, trailing commas, quotes type, and wrappings for ternary operators and variable declarations with single var.

Database tools

Managing schemas

The Schemas tab comes back to the Data Sources and Drivers dialog. Now it’s a tree with the ability to choose the current schema.

We added the Pattern field where you can describe what you want to be introspected. The Ctrl+Q shortcut will give you information about the syntax.

Importing tables

The IDE now allows you to import table schema and data from one database to another (even of a different type, e.g. from MySQL to Sql Server). To import a table, simply drag it with mouse to the data source where you'd like it to copy.

The information about the progress is published on the Database tab of Event Log.

SQL resolution scopes

Now, you can map any SQL file (or entire folder) to any datasource in SettingsToolsDatabaseSQL resolution scopes. If you do that, all unqualified objects from these locations will be resolved to the selected datasource (or database, or schema).

Default search path

Before, we set the search path according to the context of the console opening. At some point we discovered it wasn’t very convenient for many of our users. Now the default search path is set for any console. You can change it in any moment or go back to the default one.



The update includes all the Android Studio changes from v2.2.1 and v2.2.2:

The updated Docker plugin now supports Docker for Mac and works via unix://.

The Windows installer now comes with a 64-bit JDK, which means that now you can give your IDE more RAM.

Better support for Dvorak and some other non-standard (e.g. German, French, Italian, etc.) keyboard layouts.

Gogland, the new Go IDE that we announced several months ago now also becomes IntelliJ IDEA Ultimate plugin, which ends JetBrains support for the existing third-party Go plugin.

You're welcome to try the new plugin and use this FAQ to see how exactly it differs from existing one.

your edition


For web and enterprise development


For JVM and Android development
License Commercial Open-source, Apache 2.0?
Java, Kotlin, Groovy, Scala
Android ?
Maven, Gradle, SBT
Git, SVN, Mercurial, CVS
Detecting Duplicates ?
Perforce, TFS
JavaScript, TypeScript ?
Java EE, Spring, GWT, Vaadin, Play, Grails, Other Frameworks ?
Database Tools, SQL