2018.2 Jul 25


Java 11

IntelliJ IDEA 2018.2 brings support for the upcoming Java 11. The IDE now supports local-variable syntax for lambda parameters according to the JEP 323, so you can use the var keyword in lambda expressions.

Learn more

Preview data flow information in the editor

The IDE can display known data flow information right inside the editor. To see it, simply invoke the Expression type action (Ctrl+Shift+P) a second time.

Learn more

Type hints for long method chains

IntelliJ IDEA displays type hints for long method chains. This is especially useful when you want to see the type of each call as a type hint for long method chains with generics.

Configure Quick Documentation to pop-up together with autocompletion

It’s now possible to configure Quick Documentation to pop-up together with autocompletion. Simply enable the Show the documentation pop-up in… option in Preferences/Settings | Editor | General | Code Completion. Previously, the documentation pop-up could be configured to be shown only with explicitly invoked completion.

New preview panel for Extract Method

IntelliJ IDEA 2018.2 introduces a new preview panel for the Extract Method refactoring. It lets you see what the results of your refactoring will look like, before confirming the changes. This can be very useful when you refactor code fragments with duplicates.

New @Contract annotation return values

IntelliJ IDEA supports the @Contract annotation, which allows you to specify a method reaction when a particular parameter is passed. The contract information is available for various inspections and actions, which use it to produce better warnings and remove false-positives.

In version 2018.2, we’ve extended the @Contract annotation to support more return values:

  • new – every time the method is executed, it returns a non-null new object.
  • this – the method returns non-null this reference.
  • paramX – the method returns its X-th argument.

Learn more

Smarter Join Line action

We’ve upgraded the Join Lines action (Ctrl+Shift+J on Linux/Windows/macOS). Now, on any method call where the return type is the same as the qualifier type, the action will merge multiple method calls into a chained call. This also works on a declaration or assignment line with a subsequent call.

Join Lines now produces a cleaner result with a nested if, and when you are joining lines with an unnecessary 0.

Improved Stream API support

In IntelliJ IDEA 2018.2, we’ve improved support for Stream API so now it detects sorted streams that collect an unsorted collection. This indicates that either the sorting is unnecessary or that using the collector or collection is wrong.

In addition, there is a new warning about a redundant distinct() call before collect(toSet()), because when collecting to a Set, the result is always distinct anyway.


Jump outside closing bracket/quote with Tab

Now, while typing, you can use Tab to navigate outside the closing brackets or closing quotes. This works in Java, Kotlin, Groovy, SQL, PHP, JavaScript, and Python files. To enable this Tab behavior, go to Preferences/Settings | Editor | General | Smart keys and select Jump outside closing brackets/quote with Tab.

Underlining reassigned local variables and reassigned parameters

IntelliJ IDEA now underlines reassigned local variables and reassigned parameters, by default. The attributes for all the languages supporting this feature, which for now include Java and Groovy, can be changed in Preferences/Settings | Editor | Color Scheme | Language Defaults | Identifiers | Reassigned.

For and while keywords highlighted

When you place the caret at the break or continue keyword, IntelliJ IDEA highlights the for or while keyword of the corresponding loop.

User Interface

MacBook Touch Bar support

IntelliJ IDEA 2018.2 comes with support for the MacBook Touch Bar! Run, build, and debug your project, commit changes, and update the project right from the Touch Bar. IntelliJ IDEA buttons are displayed in the app-specific area in the middle of the Touch Bar interface, and they are dependent on the context or which modifier keys you press.

All available Touch Bar contexts can be customized on the Touch Bar page in Preferences | Appearance & Behavior | Menus and Toolbars.

Dark window headers

It's now possible to make the IntelliJ IDEA title bars darker on macOS. Go to Preferences | Appearance & Behavior | Appearance and select Use dark window headers.

New Icons

We’ve rolled out some brand new icons! New cleaner and simpler icons on the IDE toolbar and tool windows reduce visual clutter and ensure better readability. We believe that a clearer UI will help to maintain focus and productivity. Read the story behind the recently updated UI icons.

Updated IntelliJ theme on Linux

We’ve made the IntelliJ theme on Linux look more modern. The appearance of UI elements such as buttons, radio buttons, checkboxes, text fields, select controls, spinner, and tabs have been updated.

Version Control

Easier resolve of merge conflicts

When working with Git, now it's much easier to find files with merge conflicts. For each changelist, the IDE groups such files under a new Merge Conflicts node. Click the Resolve action link to open the Files Merged with Conflicts dialog.

Also, IntelliJ IDEA now displays Git branch names in the Files Merged with Conflicts dialog when you perform a pull, merge, or rebase. This updated dialog allows you to group files by directory, which should come in handy if there are multiple files merged with conflicts.

Enhancements in VCS Log tab

You can now delete a Git tag from a commit right from the context menu of the Log tab.

Also, the Diff Preview Panel is now available in the VCS Log.

Additionally, you can open as many Log tabs as you like.

Favorite branches in Branch filter

We’ve added Favorite branches to the Branch filter in the Log tab, so you can now quickly filter commits by your favorite branches.

Browse repository at revision

If you use Git for version control, you can now explore the state of the repository based on any given revision. Use the new Browse Repository at Revision action, which is available from the context menu in the VCS Log or from the file history, to open the required repository state in the Project Tool Window.

Multiple GitHub accounts

With IntelliJ IDEA 2018.2, you can configure as many GitHub accounts as you need (in Preferences | Version Control | GitHub), and set the default GitHub account for each of your projects.

Skip the Push dialog

While using the Commit and Push action in IntelliJ IDEA 2018.2, you can skip the Push dialog completely, or only show this dialog when pushing to protected branches. Customize this behavior in Preferences | Version Control | Git.

JVM Debugger

New breakpoint intentions

For debugging Java projects, IntelliJ IDEA 2018.2 includes several new handy breakpoint intention actions. No need to set up the properties of a particular breakpoint by hand anymore – simply press Alt+Enter and the IDE will offer you the new breakpoint intentions, along with all the other available intentions.

Ability to filter a breakpoint hit by the caller method.

In IntelliJ IDEA 2018.2, you can stop at a breakpoint if a certain condition applies to the call stack.

The new Caller filter allows you to only stop at a breakpoint if it’s called from the specified method. Or, vice versa, it will not stop at a breakpoint if it’s called from that method.


Auto-discovery of the included buildSrc Gradle project

IntelliJ IDEA 2018.2 links Gradle’s buildSrc sources and their usages in a build, so you can now navigate from the build scripts to the buildSrc source.

Debug the Gradle DSL blocks

You can now debug a Gradle script in IntelliJ IDEA. Previously, you could debug a build.gradle file only as a Groovy script. With IntelliJ IDEA 2018.2, you can now set a breakpoint not only at the top level of the Gradle build script, but also in the Gradle DSL blocks.


Project Configuration

In IntelliJ IDEA 2018.2, you can exclude some of the transitive dependencies when adding a new repository library. Click the new Configure action link in the library properties editor. In the new Configure Transitive Dependencies dialog that opens, select only the necessary transitive dependencies you want to add to your current project.

IDE configuration

With IntelliJ IDEA 2018.2, you can assign shortcuts to actions right from the Find Action dialog. Simply select the needed action, press Alt+Enter, and enter a shortcut.

Differences Viewer

Compare any text sources

In IntelliJ IDEA 2018.2, you can open an empty Differences Viewer and paste any text you want to compare in its left and right panels. The new Open Blank Diff Viewer action can be found in the Find Action dialog.


The bundled Kotlin plugin has been updated to Kotlin 1.2.51

Runnable Kotlin scratch files

Now you can run Kotlin Script scratch files and see the results right in the editor. Also, Kotlin Script scratch files can use the declarations from the code in the project.

Also, you can now create new Kotlin Script scratch files right from the Project view.

Convert end-of-line comments into block ones and vice versa.

Now there’s a handy intention via Alt+Enter to convert end-of-line comments into block comments, and vice versa.

Unused Deferred result

We’ve improved our support for kotlinx.coroutines: the IDE now reports unused Deferred results.

Merge call chain to kotlinx.coroutines.experimental.withContext

The IDE detects redundant async calls that are immediately followed by an await call, and suggests two new intentions to merge the call chain into kotlinx.coroutines.experimental.withContext:

  • async {}.await() to withContext(DefaultDispatcher).
  • async(ctx){ }.await() to withContext(ctx) { }.


Improved display of implicit conversions and arguments

The Scala plugin now can show implicit conversions and arguments as inline hints. These provide navigation and extended information in a tooltip. They are shown in the editor even when an implicit argument is used explicitly.

Inline hints can work in the editor mode. To enable this, press Ctrl + Alt + Shift + “+”. Also:

  • If you press this shortcut again, it will expand all foldings
  • Press Ctrl + Alt + Shift + “-” to collapse all foldings or disable the mode

Missing and ambiguous implicit arguments hints

We have also reworked the way errors are highlighted for ambiguous and missing implicit parameters. In addition, the Parameter Info tooltip shows both explicit and implicit parameters.

The implicit arguments popup (Cmd + Shift + P on macOS / Сtrl + Shift + P on Windows and Linux) shows the type, structure, and location of arguments.

Improved autocompletion for type annotation and pattern matching

The Scala plugin now generates an exhaustive match for sealed types with inheritors, Java Enums, and Scala Enumerations.

In pattern matching completion the Scala plugin suggests a list of typed patterns for applicable classes and interfaces, while autocompletion with TAB updates the name and type.

Scalafmt as an alternative to the built-in formatter

The Scalafmt formatter, which used to be a standalone plugin, is now part of the Scala plugin. It can be configured at Preferences/Settings | Editor | Code Style | Scala.

Semantic Highlighting

Now, you can enable semantic highlighting for your project in Preferences/ Settings | Editor | Color Scheme | Scala, and assign distinct colors to a function’s parameter, local variable, variable in a pattern-matching case clause, or variable in a sequence comprehension. Then you can scan through a function to track the variable, with no distracting action, isolate one of the variables, or switch focus to another variable.

JavaScript & TypeScript

Extract and convert React component

Use the new Extract Component refactoring to create a new React component, by extracting the JSX code from the render method of an existing one. You can also сonvert React class components into functional components, and vice versa, by using new intentions.

Find unused code

You can now find unused JavaScript code (or TypeScript code) on your client-side, by using the new Code Coverage feature. Start a JavaScript Debug configuration with coverage in the IDE and interact with your app in Chrome. Then stop the configuration, and IntelliJ IDEA will show you the coverage report in the Coverage tool window. Info about the coverage of files and folders will display on the Project view.

New integrations with Angular CLI

In IntelliJ IDEA 2018.2, you can add new features to your Angular app thanks to the integration with ng add. Use the New… | Angular Dependency… action to install libraries that support installation with ng add without using the terminal.

To generate the code with Angular schematics, use the New… | Angular Schematic… action.

New JavaScript and TypeScript intentions

Lots of new JavaScript and TypeScript intentions are now available when you press Alt+Enter: Implement interface, Create derived class, Implement members of an interface or abstract class, Generate cases for 'switch', and Iterate with 'for..of'.

Spring Integration

IntelliJ IDEA 2018.2 supports Spring Integration 5.0. There is also a new Spring Integration Diagram that visualizes the components in the system. The new diagram shows the gateways, channels, bridges, etc. that have been configured for the application using XML or Java annotations.

Spring Boot

Spring Runtime Beans diagram

In IntelliJ IDEA 2018.2, you can select the new Diagram Mode option and visualize the dependencies between runtime beans of a Spring Boot application.

Start your application and click the new Diagram Mode icon in the right gutter of the Beans tab in the Run Dashboard. The IDE will display the Spring Runtime Beans diagram for the whole application.

Access HTTP requests mappings from the Run Dashboard

Manage your HTTP requests mappings from the Run Dashboard in IntelliJ IDEA 2018.2. After you run your application, select the request you need from the Mappings tab, and then either run your HTTP request straight away or open it in the editor-based REST client.

For GET methods, you have an additional option to open a HTTP request in the browser.


YAML code formatter

Now you can reformat YAML code with the Reformat Code action which is available from Code | Reformat Code or via a shortcut: Cmd + Alt + L on macOS / Ctrl + Alt + L on Windows and Linux. Moreover, you can customize YAML code style settings in Preferences / Settings | Editor | Code Style | YAML.

Smarter YAML with JSON Schemas

Code autocompletion now works for YAML data structures that have a JSON Schema file. IntelliJ IDEA automatically traces schemas from schemastore.org, and moreover, if you need to you can manually add and configure JSON schema files Preferences/Settings | Languages & Frameworks | Schemas and DTDs | JSON Schema Mappings.

Database Tools

SQL log

Now you can use the console output to view every query that IntelliJ IDEA runs. All queries from the IDE are now logged in a text file; you can open this file via Help | Show SQL log.

New SQL formatter

Now custom Code Style schemes can be used specifically for each data source. You can assign your Code Style schemes in the Options tab of the data source properties.

Running stored procedures

Now you can execute stored Oracle and PostgreSQL procedures in IntelliJ IDEA. You can either run a procedure by selecting the Execute action from the context menu of the procedure or by clicking the Run button in the toolbar when opening the source code.

Source code migrations

Now, it’s much easier to update the source code of any objects, you just double-click the objects and make changes, and then click Commit, and the migration dialog will preview the generated SQL code to update the source code.


Navigate from compose nodes and containers

The Docker plugin now lets you navigate from compose nodes and containers to the corresponding compose and dockerfile files.

Wrapping words in Docker logs

This update adds a new Use Soft Wraps action for wrapping words in Docker logs. The new action is available via the gutter icon in the Log tab of the Docker Tool Window.

New Context folder field

Now you can specify the base directory for executing a Docker build command for a dockerfile. To do this, use the new Context folder field in the Docker run configuration. By default, the Context folder field is set to the parent folder of the specified dockerfile.

File Watcher plugin

Global file watchers

You can now store the configured File Watchers in the IDE settings and use them in different projects, as it’s now possible to set a Global File Watcher and not just one per-project, as it was before. This will help to reduce setup redundancy for developers working with many projects.

2018.1 Mar 27


Enhancements in code completion

Completion in the Stream API chains is now aware of type casting. Code completion can not only suggest a completion item according to the existing call filter (String.class::isInstance), but also for an automatically typecast completion item.

Data flow analysis

We’ve improved our data flow analysis so it can now track the relationships between variables like “greater than” and “less than.” The IDE detects when a condition is always true (or false) in all the possible code paths when the variables are compared.

The IDE will now warn you when you try to assign a variable to the same value it already contains. This may help you detect and then remove some redundant code.

The data flow analysis now works for non-terminated stream API chains.

The IDE will also warn you about modifications to immutable collections.

learn more

Missing ServiceLoader declaration

IntelliJ IDEA 2018.1 has new Java 9 inspections and quick-fixes. The IDE now checks that a service loaded by ServiceLoader is declared in the module-info.java file, and will offer a quick-fix to add a missing statement to the module-info.java file.

learn more

Creating missing class

For an unresolved class mentioned in module-info.java, the IDE will suggest creating the missing class, and create missing exported packages as well. Note the IDE creates the package with the class in the required directory, as you can’t export an empty package in Java 9.

Idempotent body detection

The IDE will detect and warn you about the while-loops with an idempotent body, as in most cases this indicates a programming error and can lead to a program hang.

Move break-condition of infinite loop to loop condition

For while-loops, now you get a notification about a conditional break at the end or beginning of an infinite loop. The IDE will suggest moving a break condition to a loop condition and offer a quick-fix to modify your loop. Usually replacing a conditional break with a loop condition makes the code clearer.

Explicitly redundant close() call

IntelliJ IDEA now detects an explicitly redundant close() call of the resource at the end of a try-with-resources block.

Infinite Stream detection

IntelliJ IDEA will warn you about any infinite streams that weren’t short-circuited, as such operations can be completed only by throwing an exception. Such code may result in an infinite loop or a running out of memory issue.

Copy constructor with missing fields detection

In IntelliJ IDEA 2018.1 you’ll get a notification if there is a copy constructor that doesn’t copy all the fields in a class. The IDE considers fields with a transient modifier unnecessary to copy.

Sort array content

A new Sort content action is available in array initializers and varargs. This new action sorts content alphabetically.

User Postfix Completion template

The postfix code completion has been improved. The IDE now lets you create your own Java templates or edit and rename some of the predefined Java templates through Preferences | Editor | General | Postfix Completion.

Fix partially in Inspection Results

A new Fix partially button has been added to the right-hand pane of the Inspection Results Tool Window. It appears when you have several options for fixing possible problems in the chosen scope. All the suggested quick-fixes are grouped by the quick-fix type under the Fix partially button. This new feature allows you to apply the required quick-fix to the chosen scope, and fix all affected cases in one go.

Test prefix in Code Generation

In IntelliJ IDEA you can generate a test class using the intention action. With IntelliJ IDEA 2018.1, you can customize a test class template and create a test class with Test as a prefix. Go to Preferences | Editor | Code Style | Java | Code Generation, and choose how the test class name should be generated. By default, the IDE creates a test class with the Test as a suffix.

JUnit 5 @Tag annotation support

IntelliJ IDEA 2018.1 now supports the JUnit5 @Tag annotation so now you can include tagged classes and tagged methods, in the testing scope. Select the Tags (JUnit 5) option in the test kind field in the Run/Debug Configuration dialog. Use the Uniqueld field to filter tests according to their id.

JVM Debugger

Throw Exception

IntelliJ IDEA 2018.1 has a new Throw Exception action that allows you to throw an exception from a certain location in your program without changing the code. It is available from the Run | Throw Exception menu, or from the frame context menu during a debugging session.

Logging stacktrace to console

The IDE now allows you to print breakpoints stack traces to the console. You can enable the stack trace option in the Breakpoints dialog box. In IntelliJ IDEA, you can now observe multiple breakpoints stack traces at the same time in the Console log.

Copy current thread stacktrace

You can now copy the current thread stack trace via a new Copy Stack action which is available from the frame context menu.

Annotations for Async stack traces

With IntelliJ IDEA 2018.1 we’ve extended the Async stack traces feature so that you can now use the @Async.Schedule and @Async.Execute annotations to set up capture points that are not included in the default configuration. You just need to add Maven artifact as a dependency.

Java Compiler

There is a new Use --release option for cross-compilation (Java 9 and later) checkbox on the Java Compiler page at Preferences | Build, Execution, Deployment | Compiler | Java Compiler that is enabled by default. When you need to use the --source and --target options with Java 9 and link against Java 9 classes at the same time, you can disable this checkbox.

You can also use a specific version of the ECJ compiler. Select Eclipse from the Use Compiler drop-down menu, and specify the path to jar with the chosen compiler.


Folded code highlighting

If any issues have been detected in your code, now you can find them quicker than before. The IDE now highlights the folded code regions that contain errors or warnings, and colors such blocks according to their validation status.

Highlights the folded code regions with the search results

The IDE also highlights folded code regions if they contain any matches when you search through the current file.

Inline external annotations

In IntelliJ IDEA you can annotate your code with external annotations even when direct annotation of the source code is not possible (library classes). You can configure your annotations in the annotations.xml files, which are stored outside of your source code. Previously the IDE only showed the @ icon in the gutter near the externally annotated code; now the IDE shows these external annotations inline in your code.

Inferred Annotation Hints

IntelliJ IDEA now lets you view the automatic inferences of @NotNull or @Nullable annotations right in your source code (not only in the gutter icon near the inferred annotation, as it was before). You can enable the Show inferred annotations inline checkbox in the Preferences | Editor | General | Appearance.

Project Configuration

Add “provided” dependencies to classpath

A new Include dependencies with “Provided” scope checkbox has been added in the Run/Debug Configurations for the Application and Spring Boot configurations. This new option will be useful if you have the provided dependencies for the scope in your project, but you run your application both inside a container (where provided dependencies are supplied by the container) and outside a container (where provided dependencies are not automatically supplied).

For the Spring Boot applications, the Include dependencies with “Provided” scope option is enabled by default.

New Change Module Names... action

With IntelliJ IDEA, you can now change qualified names for multiple modules all at once. This is done via the new Change Module Names… action, from the context menu of the Project Structure dialog.

Search and Replace

Structural Search enhancement

With IntelliJ IDEA 2018.1, you can find method calls to annotated methods using Structural Search. You can select them from the existing search templates or create your own.

Replace in Path improvements

IntelliJ IDEA 2018.1 has the ability to preview a regex replacement in the Replace in Path dialog.


The Kotlin plugin bundled with the IDE has been updated to Kotlin 1.2.30

Pasting Kotlin code into a package

Now, in the Project Tool Window, you can paste a code fragment directly into a package, and the IDE will create a new Kotlin file with the pasted code.

Intentions for converting the scoping function calls

The Kotlin Plugin now offers new intentions that convert the scoping function calls let and run into each other, as well as also into apply and vice versa.


New Convert to @CompileStatic refactoring action

Now you have a new action that’s very useful when you want to keep your code in Groovy and at the same time benefit from static compilation. To save you a lot of time migrating from existing Groovy code, this new refactoring annotates every groovy class in the scope with the @CompileStatic annotation.

This new refactoring action is available from the context menu Refactor | Convert to @CompileStatic.

learn more

Unnecessary import alias

IntelliJ IDEA 2018.1 reports unnecessary import alias for Groovy files. This new warning also works on static imports.


Inline hints

The editor can now show inline hints for parameter names, method result types, and variable types. You can also easily use the settings to customize when such a hint should be shown.

Structure View improvement

The Structure View now shows much more information about code. It displays final, abstract and access modifiers, nested definitions, primary constructor types, case class parameters as members, etc. The Structure View also provides you with an option to show all inherited members with their original class.

Refactoring: Inline function parameters

The refactoring is now capable of inlining functions with parameters. It correctly substitutes them with actual values.


IntelliJ IDEA 2018.1 merges the changes from Android Studio 3.0 and includes dozens of new features, with the following major new ones

Layout Editor improvements

The Layout Editor has been improved: there is a new toolbar layout and icons, updated layouts in the component tree, a new error panel, and more.

Brand new profiling tools

IntelliJ IDEA 2018.1 now includes Android Profiler, a brand new suite of profiling tools that provide real-time data for your app’s CPU, memory, and network activity.

Device File Explorer Tool Window

The new Device File Explorer Tool Window displays the file and directory structure of your Android device or emulator. Use this tool window to view, copy, and delete files on an Android device. You can access it through View | Tool Windows | Device File Explorer.

Build Instant Apps

The IDE now supports the ability to build Instant Apps – lightweight Android apps that can be run without installation. To start building Instant Apps, make sure that the Instant Apps Development SDK is installed. You can check which SDK tools are installed in Preferences | Appearance & Behavior | System Settings | Android SDK in the SDK tab.

Spring Boot

Access HTTP request mappings from the editor via the new REST client

Now, after you run a Spring Boot web application, a new icon is shown in the gutter for methods with @RequestMapping annotations that handle incoming HTTP requests. Click this gutter icon to open all the mappings in a scratch file with an .http extension and perform an HTTP request in the editor via the new REST client.

For methods with @GetMapping annotations, you have the choice to open the mapped URLs in a browser, or open a request in the HTTP Request Editor.

Note, that you need to add the dependency for the spring-boot-starter-actuator to your pom.xml or build.gradle file.

New gutter icons for beans registered in the application context

IntelliJ IDEA shows all the beans that are registered in the application context in the Beans tab in the Run Dashboard (or in the Run Tool Window). We’ve extended this functionality, and now this information is also available in the editor. The new gutter icons are shown next to the beans that are used at runtime.

Click these new gutter icons to navigate to the dependent beans.

Version Control

Partial Git commits

IntelliJ IDEA 2018.1 supports partial Git commits (git add -p). The IDE lets you associate the code chunks with a changelist. Create a changelist, put all the needed code chunks there, and then commit it. The IDE will now only commit the selected changes from the file and will skip all other changes. To add the code chunks to a commit, use the checkboxes in the gutter in the Diff pane of the Commit Changes dialog.

To move the code chunks between changelists, use the Move to Another Changelist... action from the context menu of the Diff pane in the Commit Changes dialog.

Alternatively, add code chunks to a changelist from the editor by clicking on a change marker in the gutter.

Toggle grouping of local changes by directory, module, or repository

With IntelliJ IDEA 2018.1, you can choose how to display your local changes by grouping them according to their directory, module, or repository. Use the new Group by icon available in the Local Changes tab in the Version Control Tool Window. Note that now you can select one of the grouping options or all three at once if needed.

Navigate by clicking on the commit hash

In the Log tab inside the commit detail panes, the IDE now highlights hashes of the commits you are referring to. By simply clicking commit hashes you can jump to that commit in the Log tab. This works for Git and Mercurial. Also, the Commit Details pane of the Log tab has been redesigned

History for revision tab enhancement

IntelliJ IDEA lets you view detailed information about file changes by invoking the Show History for a Revision action on a file in the Log tab (available for Git integration). In 2018.1, we’ve updated the History for revision tab so that now it works much faster. In addition to better performance, this tab has a refreshed UI resembling the Log tab.

Clone Repository

Moreover, the Clone Repository dialogs for Git and GitHub have been merged into one.

Autocompletion for GitHub repositories also works in the new Clone Repository dialog. You just need to log in to your GitHub account by clicking Log in to GitHub.

New shortcut for the Commit and Push… action

The IDE has a new default shortcut to perform the Commit and Push… action from the Commit Changes dialog. Please use Alt + Cmd + K (on macOS) or Alt + Ctrl + K (on Windows and Linux).

Git Branches pop-up

The Abort Rebase, Continue Rebase, and Skip Commit actions are now available from the Git Branches pop-up if there is an ongoing rebase process.

User Interface

New documentation UI

We’ve updated the Quick Documentation pop-up and made it clearer and more compact. Information about the method’s parameters, type, and return type is now available for Java, JavaScript, and TypeScript in the updated Quick Documentation pop-up

Better HiDPI support

When you run the IntelliJ IDEA 2018.1 on Windows 8.1 (or higher), the IDE starts in per-monitor DPI-aware mode, with implemented support for the fractional scale factors of the monitor. Previously only integral scale factors were supported in the IDE. To switch back to the default mode, you need to set-up the VM option -Dsun.java2d.uiScale.enabled = false

JavaScript & TypeScript

TypeScript improvements

IntelliJ IDEA now supports the latest TypeScript 2.7 features, improves the Implement Members action, and adds the new Surround with type guard quick-fix for unresolved properties.

Create a new Vue project

With the Vue.js plugin installed in IntelliJ IDEA, you can use Vue CLI, an official tool for scaffolding Vue apps, to create new Vue projects. To install Vue CLI, run npm install --g vue-cli in the terminal.

Reformat with Prettier

IntelliJ IDEA supports Prettier, an opinionated code formatter via Prettier plugin. After you have the prettier package installed, the new Reformat with Prettier action will become available in IntelliJ IDEA. You can format the selected code, a file, or a whole directory using Prettier.


Hunspell dictionary support

The Hunspell plugin that provides Hunspell dictionary support is now compatible with IntelliJ IDEA. Compared to a plain list of words, Hunspell provides significantly faster and much more accurate misprint detection, with far fewer false positives.

learn more


Enhancement in Docker compose

The Docker plugin now supports Multiple Docker Compose files and respects not only a docker-compose.yml but also an optional docker-compose.override.yml file. You can add docker-compose.override.yml as you would any other override file, right after the base configuration file.

Docker compose services

The Docker plugin allows you to choose the services to run just after choosing the configuration files in the Docker-compose run configuration.

The plugin shows all the existing Compose projects, not only the ones deployed via the Docker-Compose run configuration.


Support for YAML Kubernetes resource files

The brand new Kubernetes plugin supports the Kubernetes resource files from v1.5 up to the recently released v1.9. The new plugin will look for the presence of apiVersion and other fields of this kind in the files, and if these are present, it will consider such files as Kubernetes resource files.

learn more

Completion in YAML Kubernetes resource files

To help you really quickly create the required YAML definition file for Kubernetes, start typing the required key and invoke Smart Completion. The new plugin will auto-complete all the required keys from all the levels below.

Code completion now works for YAML Kubernetes resource files. The Kubernetes plugin offers the correct values you can use within the resources.

Kubernetes Live Template

The Kubernetes plugin has a built-in Live Template that allows you to quickly create the type of YAML Kubernetes resource file that you need. The new plugin now contains several predefined Kubernetes templates, and you can invoke the necessary Live Template by typing its abbreviation.

Navigation in YAML Kubernetes files

Use gutter icons to quickly navigate between a label definition and a label selector.

Jump from a label selector to a label definition inside the editor if there is a direct match for a label, both for the key and for the value.

Inspections for YAML Kubernetes files

The Kubernetes plugin will alert you whenever you select deprecated Kubernetes properties.

Also, you’ll get a warning for YAML files if you try to use properties that are not applicable for the specified elements with the applied apiVersion and kind of field.

Quick-fixes for YAML Kubernetes files

The plugin highlights elements with missing keys in YAML Kubernetes resource definition files and provides a quick-fix to add the required keys.

Also, you'll get a warning about redundant keys. Use the provided quick-fix to remove redundant keys in YAML Kubernetes resource files.

The new plugin also detects non-editable keys in YAML Kubernetes resource files and highlights them in the editor. Note that there’s an easy way to remove all such read-only keys from the current YAML file – with a handy quick-fix.

Support for JSON Kubernetes resource files

The new plugin provides some support for JSON Kubernetes resource files based on the JSON schema functionality.

Code completion and the Quick Documentation Popup are also available for JSON Kubernetes resource files.

Inspections for JSON Kubernetes resource files

The new Kubernetes plugin validates the current keys according to the JSON schema and alerts you when incorrect properties or values are used.

Also, the plugin highlights elements with any missing required properties and then advises you about the appropriate properties that should be added.

Duplicated properties are also detected in JSON Kubernetes files.

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.

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