Keeping track of IntelliJ IDEA 2018's progress

IntelliJ IDEA progress report: 2018.3.3 brings changes to the way Raw String Literals is supported in IntelliJ IDEA

JAXenter Editorial Team
IntelliJ IDEA 2018.1

© Shutterstock /Vector Goddess

Time to check in on IntelliJ IDEA 2018! A new year, new bug fixes. Although the calendar might say 2019, IntelliJ IDEA 2018.3.3 is going strong with a number of bug fixes, updates, and performance improvements for developers to enjoy.

Although it may be 2019, we’re still keeping an eye on what’s up with IntelliJ IDEA 2018. And so, a new year brings new bug fixes! IntelliJ IDEA 2018.3.3 is available for download here.

Also, as the new year changes over, we’ll keep updating this thread so long as the 2018 IDE does. Of course, we should probably keep our eyes peeled for an IntelliJ IDEA 2019 on the horizon…

JetBrains’ Zlata Kalyuzhnaya has the complete details about all the changes to IntelliJ IDEA 2018.3 in this blog post.

IntelliJ IDEA 2018.3.3

There’s been a lot of discussion already about what’s going on with the JDK 12. For those of you just coming back from winter break, JEP 326: Raw String Literals was withdrawn from JDK 12. (We’ve covered some of the conversation here.) As such, it’s no longer automatically ported to the latest release of Java. So, developers who want to give this JEP a whirl in 2018.3.3 need to set the project language level to X-Experimental features.

Other improvements

  • The Kotlin plugin was updated to v1.3.11.
  • 2018.3.3 works correctly with Maven 3.6.0
  • Performance improvements for the Thymeleaf plugin
  • Four bug-fixes for Groovy
  • The commit message is no longer lost after canceling a commit if the task server is configured with the “Add commit message” option enabled.
  • And a number of regression fixes!

The full release notes are available here. As always, if you encounter any issues, please report them to the issue tracker!



Update November 23. 2018

It’s here! IntelliJ IDEA 2018.3 is available for download.

We’ve been keeping track of all the exciting features that are now ready for developers to use (see our posts below for more information). 2018.3 is chock full of new capabilities and features, including support for the upcoming Java 12, GitHub pull requests, multiline TODO comments, and more!

JetBrains’ Zlata Kalyuzhnaya has all the details for IntelliJ IDEA 2018.3 in this blog post.

IntelliJ IDEA 2018.3 Highlights


It might not be here yet, but IntelliJ IDEA 2018.3 comes with initial support for the upcoming Java 12! Developers can already preview future JEPs like Raw String Literals. With this JEP, developers can convert multiline string literals to raw string literals and vice versa, detect redundant leading or trailing backticks (`), and spell check!

Fair warning: since Java 12 is not yet out, this feature isn’t completely bug proof and is for testing & evaluation purposes only!

The new IntelliJ is much better at finding copies in complicated cases, even if it’s slightly hidden by differing variable names. Now, 2018.3 displays duplicates in the diff viewer, so developers can compare them side by side.

Other changes include some Java Stream API improvements; 2018.3 now goes through and detects redundant sorted calls before the subsequent min call. There’s a quick fix that removes those redundant sorted calls as well.

IntelliJ IDEA 2018.3 also boasts a new data-flow-based inspection called Condition is covered by further condition. It detects situations where the first condition is not needed since there is a second one that already provides coverage. There’s a quick fix that remove these kinds of redundant conditions.

Following this theme of getting rid of redundancies, 2018.3 also detects unnecessary usages of:

  • @SuppressWarning annotation
  • // noinspection line comment
  • /** noinspection */ JavaDoc comment

Now, the IDE will give developers a warning if a suppressed inspection no longer addresses anything in the associated method body, class, or statement. It’ll also give a quick fix to remove unneeded annotations or comments.

More information about the Java changes is available here.


IntelliJ IDEA 2018.3 has a number of helpful editor changes to make life easier for developers.

Now, developers can take advantage of multiline TODO comments. Thanks to this change, the IDE highlights the first and all subsequent TODO comment lines in the editor and displays them in the TODO tool window. All developers have to do is add an indent starting from the second line of their multiline TODO comment and the IDE takes care of the rest!

Formatting can be further customized in the editor as developers can disable code formatting for specific files and folders. This keeps certain files safe from implicit or explicit formatting, imports optimization, and code rearrangement. Just create a scope and add it to the files you want kept safe from future formatting.

There’s also a new indentation status bar that displays the size of the indent in the current file. This is to make sure any given file’s indentation matches the current settings of the rest of the project.

The EditorConfig improvements include syntax highlighting and code completion. Use the new indentation status bar popup to navigate to the EditorConfig file being used.

More information about the Editor changes is available here.

Version Control

Preview your pull requests in IntelliJ IDEA with GitHub Pull Requests! Now, developers can view all the pull requests from their GitHub repos with this new tool window. They can use the diff to preview changes, or create a local branch from a Pull Request via the context menu then merge it as a regular branch.

There’s more support for Git submodules. Developers can clone or update their projects, commit changes, view diffs, and resolve conflicts. They can also copy a file from one Git branch to another with the new Get from Branch action.

The History up to Here action has also been upgraded. Before, it only showed the file’s history up to a selected commit. Now, it shows what happened to the file afterwards by switching to Show All Branches.

More information about the Version Control changes is available here.

Kotlin, Spring Boot, and other improvements

  • The bundled Kotlin plugin for IntelliJ IDEA 2018.3 has been upgraded to v1.3.
  • It already supports the recently released Spring Boot 2.1
  • Developers can delegate all their build and run actions to Maven.
  • The new Run Anything action allows developers to run configurations, terminal commands, Gradle tasks, or any other kinds of commands.
  • Search Everywhere supports a number of functions, including Search Everywhere, Find Action, Go to class, Go to file, and Go to symbol. Developers can also search for multiline fragments in the Find in Path dialog. Additionally, Structural Search & Replace supports autocompletion in the search field, more flexible scope configuration, and more.

More information about these changes can be found in the full change log.

This is just the highlights reel of the new release, so don’t forget to check out Zlata’s blog post for an overview of IntelliJ IDEA 2018.3.



Update October 25, 2018

IntelliJ IDEA 2018.3 Beta is now available for download.

There are a bunch of interesting features coming in the next major update, including initial support for GitHub Pull Requests, Git submodules support, Multiline TODO comments, better project and IDE navigation, accessibility improvements, JVM Profiler (for macOS and Linux), and more.

JetBrains’ Zlata Kalyuzhnaya summarizes all the goodies included in IntelliJ IDEA 2018.3 in this blog post.

IntelliJ IDEA 2018.3 Beta: Highlights

Better navigation over the project and IDE

There’s a new and improved Search Everywhere dialog which incorporates all of the other types of navigation dialogs: Search Everywhere (Double Shift), Find Action (Ctrl-Shift-A / Cmd-Shift-A), Go to class (Ctrl-N / Cmd-O), Go to file (Ctrl-Shift-N / Cmd-Shift-O), and Go to symbol (Ctrl-Alt-Shift-N / Cmd-Alt-O). They all have their own separate tabs in the new dialog, and you can even use the TAB button to switch between them.

If this is not your cup of tea, you should know that you can still access all the navigation dialogs through their original keyboard shortcuts, as before.

Run Anything

You should also give the new universal action called Run Anything (Double Ctrl) [which is basically a new unified way to run any and all commands in IntelliJ IDEA] a try. You can launch any run configuration, including Maven and Gradle run configurations, or run a Gradle task and you can also use it to run terminal commands.

Plus, there’s nothing easier thank debugging a configuration of your choice. All you have to do is press the Shift key to switch the dialog to the Debug Anything mode.

Reworked plugins preferences page

Since we’re talking about changes and improvements, the IntelliJ IDEA team has made it easier to manage all the existing plugins, and to search for and install new ones. That means you can search for plugins by categories, and sort the search results by the number of downloads, rating, or update date. Plus, you can view all the new and updated plugins, the top downloaded plugins, and the top-rated plugins from inside the IDE.

If there are plugins that need to be updated, you’ll find them in the dedicated Updates tab. Furthermore, you can now see all the downloaded and bundled plugins separately under the Installed tab.

We’ve barely scratched the surface so don’t forget to check out Zlata’s blog post for an overview of IntelliJ IDEA 2018.3 Beta.



Update September 6, 2018

The first EAP build of IntelliJ IDEA 2018.3 is live and you’ll be amazed at all the new stuff it brings!

Let’s take a closer look at what the JetBrains team prepared for us!

IntelliJ IDEA 2018.3 EAP: New features

Search Everywhere – Introducing a better way to navigate over the project and the IDE  with the new Search Everywhere dialog. It has a nicer UI, and it’s resizable and movable. It incorporates Go to class, Go to file, Go to symbol, and Find action!

Run Anything – Introduces a new Run Anything action (Double Ctrl) – a new centralized way to run a command in the IDE.

Multiline TODO comments – The long-awaited support for multiline TODO comments is here!

Plugins page – The Plugins page in Preferences/Settings is completely reworked and it’s now much easier to manage, install, uninstall, and update plugins.

Structural Search – New simplified Structural Search & Replace dialogs.

JVM Debugger- hereThere are a number of debugger improvements with this release. You can check them out in detail .

Maven- You can now delegate all your build and run actions to Maven. Enable the new option, Delegate IDE build / run actions to maven, by going to Preferences / Settings | Build, Execution, Deployment | Build Tools | Maven | Runner.

Editor – You can now configure the default indent for your projects on the Tabs and Indents tab in Preferences / Settings | Editor | Code Style | Java.

Java- There’s a bunch of new Java inspections and quick-fixes. Take a closer look here.

Run Configurations – IntelliJ IDEA now supports macros in run configurations.

VCS – Further enhancements for the integration of IntelliJ IDEA 2018.3 with Git.

Check out the full changelog and try out all the amazing new features here.


Update July 18, 2018

No rest for the JetBrains team!  The second Release Candidate of IntelliJ IDEA 2018.2 is here; it can be downloaded from the website, updated via Toolbox App, or you can just use patches for the in-product update if you’re using the previous RC build. according to the blog post announcing the news.

One more thing, though: You’ll need an active subscription to IntelliJ IDEA Ultimate, or, if you don’t have one, you can use a trial license. 

RC2 comes with improvements in the MacBook Touch bar support such as a new Welcome dialog layout, the “Add configuration” button is now in the Run/Debug configuration dialog and more. Check out the release notes if you want to discover all the changes.


Update July 17, 2018

It’s not an update without improvements for the Spring framework and Spring Boot. 2018.2 now offers support for Spring Integration 5.x.

Now, IntelliJ IDEA clearly defines configured components, whether they are gateways, channels, bridges, etc. It doesn’t matter if these components were configured with XML or Java, the diagram shows them regardless.

Code completion and navigation is also available for integration annotations like @BridgeTo/From and @EnablePublisher.

2018.2 also provides a number of small but highly useful updates for Spring Boot. Developers can view the Spring dependencies in diagrams. Now, developers can do the same for the runtime dependencies of a Spring Boot application. Just start the application, go to the Endpoints tab, and enable “Diagram Mode” on the Beans tab.

There are a lot of beans to keep track of, so the Beans tab in Endpoints has a new feature to manage them. With the “Show Library Beans” button, developers can show or hide beans that do not belong to their code.

Additional features include the ability to run, edit, and test HTTP request mappings from Mappings in the Endpoint tab. Developers can also contribute new tabs under the Endpoints tab with the  updated API.

Check the full changelog for all the updates and bugfixes for Spring and Spring Boot.

2018.1.6 is here!

One of the last stops before 2018.2 is finishing off all the updates and upgrades already in progress. 2018.1.6 is here, with a few good bug fixes.

  • Fixed a throwable exception: unable to get stub builder: IDEA-181227.
  • Fixed the issue that caused the go to Class/File/Symbol pop-ups to leak via the native window and focus traversal policy: IDEA-192184.
  • Corrected the treatment of a Spring @Nullable annotation: IDEA-182842.

Check out the release notes for the complete list of fixes and improvements!


Updated July 11, 2018

2018.2 first release candidate ready to download

IntelliJ IDEA 2018.2 is just around the corner now that the first release candidate is here.

Here are some of the improvements that you’ll find in this release candidate:

  • IntelliJ IDEA warns you about any blocking calls in lambdas within a reactive pipeline
  • Multiple bug-fixes in the Spring Integration support.
  • The Kotlin plugin bundled with the IDE has been updated to v1.2.51.
  • The JDK was updated to version 1.8.0_152-release-1248-b89.

You can download it here

You won’t find loads of major improvements but you’ll be happy to know that the first release candidate comes with some really great Spring Integration 5.x improvements, such as support for the Spring Integration annotations [@BridgeFrom and @BridgeTo annotations], and for the @EnablePublisher annotation.

The Reactor support has also been improved, which means that IntelliJ IDEA can now warn you about any blocking calls in lambdas within a reactive pipeline. They also fixed false positives in the Blocking operator call in non-blocking scope inspection, as well as some issues in the Run Dashboard, which now honors the ‘Single instance only’ flag of Run/Debug configuration dialog for Spring configuration [IDEA-188758] Remember the issue that caused the current run configuration to delete when pressing the Del key in the Search field of the Console tab of the Run Dashboard (*cough*IDEA-189873*cough*)? That’s also been fixed.

This announcement wouldn’t be complete without Kotlin so here it goes: the Kotlin plugin bundled with the IDE has been updated to v1.2.51. Speaking of updates, the JDK was updated to the version 1.8.0_152-release-1248-b89.

The full list of changes is available in the IDE and JRE release notes.


Updated July 2, 2018

IntelliJ IDEA 2018.2 beta

IntelliJ IDEA 2018.2 beta is here!  The list is set for v2018.2; now it’s just time to polish the silver and check for any pesky bugs hiding around a corner. This preview has everything that’s on offer for 2018.2, so let’s take a closer look at what’s in store for developers!

Improved user interface

2018.2 comes with Mac Touch Bar support, making it easier for macOS developers to utilize the IDE from their own touch bar. Now, developers can run, build, and debug their projects in 2018.2 with the touch of a button.

These buttons are displayed in the app specific section of the Touch Bar interface. It should be noted that these buttons are dependent on context and which modifier keys are pressed. However, they are also highly customizable and cab be changed according to your preferences via the Touch Bar page in Preferences | Appearance & Behavior | Menus and Toolbars.

Other UI changes include a dark theme for Mac users as well as some brand new icons.


Navigate outside the closing brackets with IntelliJ IDEA’s newest setting! By enabling the Jump outside closing brackets/quote with Tab smart key, developers can do exactly that. 2018.2 allows this feature for any files in Java, Kotlin, Groovy, SQL, PHP, JavaScript, and Python.

Additionally, the default visual setting for reassigned local variables and reassigned parameters is now underlined, to make it clearer to developers when things get moved around. This feature is available for both Java and Groovy.

Plus, when developers put a caret at the break or continue keyword, the IDE highlights the for or while keyword of the corresponding loop.


Java 11 should be on our doorsteps sometime in September. In the meantime, IntelliJ is making sure the IDEA 2018.2 is ready. This includes support for some upcoming JEPs, like local-variable syntax for lambda parameters. Find out more information about Java 11 in IntelliJ IDEA 2018.2 here.

In other news, developers can display known data flow information inside the editor with the Expression type action. Just type Ctrl+Shift+P twice and a small popup box appears with information about an actions type and nullability.

2018.2 can also display autompletions and Javadoc at the same time. As long as the Show the documentation info pop-up in… option is enable, both popups can appear in the editor at the same time. Check the settings at Preferences | Editor | General | Code Completion.

Along the same lines, 2018.2 displays type hints for long method chains. Sometimes, you need a little help to make sure the right type goes with the right method chain. That being said, the IDE hides the type hint for simple builders with obvious types.

Additionally, existing inspections have been updated as a result of Java 10 API changes. Keep an eye out for the loop to Stream API (and the reverse Stream to loop) changes for UnmodifiableList, UnmodifiableSet, and UnmodifiableMap.

New @Contract annotation return values

Want to use @Contract and specify a method reaction for when a particular parameter is passed? Developers tend to uses these annotations to get better warnings and remove false positives. There are now more return values for @Contract, including:

  • new – returns a non-null new object when a method is executed
  • this – the method returns non-null this reference
  • paramX – the method returns its X-th argument

More information about @Contract annotation returns can be found here.

JVM debugger

The JVM debugger has gotten a couple new improvements. For one, developers have breakpoint intention actions for debugging a Java project and don’t need to set up the properties by hand anymore. By pressing Alt+Enter, the IDE automatically offers developers new breakpoint intentions along with all other available intentions.

Additionally, developers can filter a breakpoint hit by the caller method. This allows developers to stop at a breakpoint if a certain conditional applies to the call stack.

Get the IntelliJ IDEA 2018.2 beta

More information on the complete 2018.2 beta is available here! Want to test drive all the cool new features that will be in v2018.2? Download the beta here!


Updated June 26, 2018

IntelliJ IDEA 2018.2: Data flow analysis

Want to figure out what bugs might be lurking in your code? Instead of laboriously searching for an error, IntelliJ IDEA 2018.2 brings improvements to data flow analysis and code simplification.

IntelliJ IDEA analyzes the data flow; if there are any suspicious bits of code, it’ll give the user a warning. Now, IntelliJ IDEA 2018.2 gives extra information about a particular symbol.

IntelliJ IDEA gives warnings in the editor if it detects suspicious code based on an analysis of data flow.  In IntelliJ IDEA 2018.2 we can now see information known about a particular symbol. By typing Ctrl+Shift+P twice, it shows what kind of value this highlighted code might have.

While it works with many known values, the data flow analysis works best with array values.  Now, IntelliJ IDEA shows the possible values from an array if it were statically initialized or if it was initialized as an empty collection. This kind of data flow analysis also supports more math operations like division and right shift.

Developers can also look inside streams with Stream.of() to make sure that the downstream operations are logical, evaluating if this code can be simplified.

There is even increased support for evaluating simple methods, checking to see if certain conditions will always or never be true with Math or String methods. Methods supported on String are:

  • contains
  • indexOf
  • startsWith
  • endsWith
  • lastIndexOf
  • length
  • trim
  • substring
  • equals
  • equalsIgnoreCase
  • charAt
  • codePointAt
  • compareTo
  • replace

Methods supported on Math are:

  • abs
  • sqrt
  • min
  • max

More information can be found here.


Updated June 22, 2018

IntelliJ IDEA 2018.2 EAP 6

It’s time for another EAP build for 2018.2! We take a look at what’s in both EAP 5 and EAP 6: Docker improvements, global file watchers, darker themes, and more.

Docker improvements

Developers will have better integration with Docker for IntelliJ IDEA 2018.2. With the “Context folder” feature, it is possible for developers to specify a base directory for executing a Docker run configuration. The Context folder is a new field in the Docker run configuration. It is set to a parent folder of whatever dockerfile is specified.

There are also a number of new runtime command line options:

  • All the memory options
  • --security-opt
  • The option to support –runtime=nvidia

Developers can also opt to use --rm in Docker Run/Debug Configurations. This launches a temporary container that is cleaned up automatically upon termination.

The Use Soft Wraps action wraps the words in Docker logs for easier reading and clarity.

File Watchers

The File Watchers plugin has gotten a bit of an upgrade to reduce setup redundancy for multiple projects. File Watchers executes tasks on file modifications. Developer can now choose to do so on the project level or on the global level. This is not limited to once per-project, either!

Start getting ready for 2018.3

Search Everywhere is getting a total rewrite! You can start playing around with the new dialogue as Search Everywhere, Go to class, Go to file, Go to symbol, and Find action have been merged together. This is available in the experiential features option from the Maintenance dialog. Keep in mind that this is under active development, so objects may shift around during the flight.

IntelliJ IDEA 2018.2 EAP build is available here for Download. For more details, please refer to the release notes.


IntelliJ IDEA EAP 5

User interface

Looking for a darker theme? If you want it darker, then Darcula has got it covered for the macOS. enable the Use dark window headers option to make the IntelliJ IDEA title bars even darker than before.


To improve comprehension and clarity, IntelliJ IDEA now highlights the corresponding loop of a for or while keyword when developers place a caret at the break or continue keywords.

Version Control Systems

Developers can now explore the repo state of any given revision using a new action, Browse Repository at Revision. This is available from the file history or from the VCS Log.

Additionally, the “unregistered roots detected” issue has been clarified. IntelliJ IDEA now registers the Git and Mercurial repositories automatically on the project opening as VSC roots.

EAP 5 and 6 come bundled with Kotlin v.1.2.50. This comes with support for runnable Kotlin scratch files and more.


For the full list of fixes, please check out the release notes.


Updated June 15, 2018

IntelliJ IDEA 2018.1.5

2018.1.5 has arrived for IntelliJ IDEA. This latest update brings a number of fixes for some pesky bugs as well as some solutions for a few unpleasant regressions. Here’s what developers can expect from this update.

As for bug fixes, developers should check out the release notes for the whole nine yards. Here are some of the big ones:

  • The IDE can keep on track after using or canceling navigation pop-ups or menus  (IDEA-191839)
  • No more errors when navigating to class with Ctrl+N or cmd+O  (IDEA-191860).
  • Projects can store .iml externally without a compile fail  (IDEA-191328).
  • No more duplicate changelists if parts of the files are submitted to a Perforce changelist (IDEA-191521).
  • Expressions can be evaluated in the lambda body now (IDEA-191797).

As always, feedback is welcomed and any issues should be reported to the issue tracker. Download the update through the IntelliJ website or via the Toolbox App.


Updated May 30, 2018

The latest EAP for 2018.2 is here. With it comes improved support for @Contract annotations, breakpoint intentions in the JVM debugger, and Git integration for the version control system.

IntelliJ IDEA 2018.2 EAP3

@Contract annotations

IntelliJ IDEA already supports the @org.jetbrains.annotations.Contract annotation and has done so for a while. These annotations allow developers to specify a method reaction when a predetermined parameter is passed. In general, this is used for nullability analysis along with other inspections.

This latest update builds on previous improvements like automatic inference. Now, the Contract language supports more return values, making it easier for developers to use and giving them a better understanding of their methods results.

In particular, this update of the @Contract annotations makes it easier for developers to detect bugs in their code. IntelliJ IDEA even provides annotations from a Maven repo library for a quick fix for some detected problems.

JVM debugger

Our last update (see below) went over the new breakpoint intentions available in IntelliJ IDEA 2018.2. Accessible by Alt+Enter, its new functionality includes filtering by a caller method.

Thanks to this new ability to filer breakpoints by the caller method, it’s possible to stop only when a certain condition applies to the call stack.  Developers can also set a caller method filter by using the Caller filers field in the Breakpoint dialog.

Version control system

Git integration has been improved in 2018.2 with a useful new feature: the IDE autocompletes tags in the Checkout dialog. This little feature improves the user experience quite a bit, making it easier to find the right tag when you need it.

Download the latest version of IntelliJ IDEA 2018.2 here through the Early Access Program!



Updated May 23, 2018

Double update today! Not only is IntelliJ IDEA 2018.1.4 here, but there are also new features for 2018.2 EAP2!

IntelliJ IDEA 2018.1.4

First things first, let’s take a quick look at 2018.1.4. This is the fourth bugfix for the 2018 major version.  Let’s take a look at some of the changes and bugfixes on offer.

Developers can now specify the directory to be used by the running application for each run configuration. This can be entered directly or with path variables.

IntelliJ IDEA 2018.1.4 supports Spring Boot 2’s relaxed binding rules for configuration keys.

Initially, $MODULE_DIR$ variable pointed to the directory containing .iml files. Projects imported from Gradle have the .iml file in the .idea directory. The .idea directory shouldn’t be used as a working directory for tests, due to test failures. So, now $MODULE_DIR$ points to the module’s content root, to avoid this scenario.

As  a result, the $MODULE_DIR$ macro has been depreciated. There are two new macros:

  • $MODULE_WORKING_DIR$ for module content directory.
  • $MODULE_IML_DIR$ for directory containing the .iml file.

For a full list of all the changes, head on over to the IDE and JRE release notes. You can get the latest major version bugfix as a download from the IntelliJ website or as an update via Toolbox App.

IntelliJ IDEA 2018.2 EAP2

The EAP for IntelliJ IDEA 2018.2 opened a week ago and there’s more to see with the EAP2! Specifically, more about the JVM debugger and the code refactoring feature.

JVM debugger

The IntelliJ IDEA 2018.2 is going to bring new breakpoint intentions in the JVM debugger. Right now, you can limit the breakpoint to only hit particular object instances or define the class to be hit or not hit. However, this needed to be done by hand through a number of different filters and clicking o buttons.

The new JVM debugger offers a number of helpful intention actions, including

  • Stop only in class
  • Do not stop in class
  • Stop only in the current object

Just press Alt+Enter during a debugging session and the IDE will offer you a bunch of new breakpoint intentions!

Code refactoring

Additionally, IntelliJ IDEA 2018.2 offers a new preview panel for Extract Method refactoring. This should come in handy for performing refactoring on code fragments with duplicates.

Just use the shortcut Ctrl+Alt+M for the Extract Method dialog to preview all the changes in one place. Now, the IDE provides developers with the option to review the results of the refractoring… before it takes place!


For a full list of all the changes, head on over to the IDE release notes. You can get the latest major version bugfix as a download from the IntelliJ website. All feedback is welcome!


Updated May 15, 2018

The IntelliJ IDEA 2018.2 Early Access Program is here! This release offers number of new features, including MacBook Touch Bar support, Gradle improvements, and more! Please see the changelog for the complete listing of updates.

MacBook Touch Bar

In particular, Mac users should be pretty happy with the upcoming support for the Touch Bar – this has been waiting in the wings for some time and it should ship with the 2018.2 general access release. However, if you want to try it, the EAP makes it possible for developers to run, build, and debug your project straight from the Touch Bar.

Impressively, the Touch Bar displays the contextually relevant controls for IntelliJ IDEA. The Touch Bar buttons can even be customized based on what actions you’d like to do. This includes using tools like Maven or Gradle, as well as configuring, debugging, and even committing a project. Additionally, the tool bar can even be modified under the Menus and Tool Bars tab under Appearance & Behavior.

This feature is quite new, so all feedback from you Mac users is heartily appreciated.


IntelliJ IDEA’s code completion tool is a work in progress, but 2018.2 EAP now shows autocomplete options and Javadoc at the same time. This feature needs to be enabled to try in the EAP. Another feature to make developer’s lives easier is the display option for known data flow right is inside the editor. To start, you need to invoke the Expression type action for the second time.

Additionally, there have been some downstream effects due to Java 10 API changes, including some code changes here and there for looping to stream API migration inspection and vice versa. Thanks to IDEA upgrades, the Stream API support has been improved for unsorted collections and Boolean expressions for more than three stream elements.

In the future, IntelliJ IDEA 2018.2 will support Java 11!


Developers can now debug a Gradle script in IntelliJ IDEA. The debugger can connect to the Gradle daemon. Also, the auto-discovery of an included buildSrc Gradle project now works.

Spring and Spring Boot

IntelliJ IDEA makes it easier to analyze complex Spring and Spring Boot projects with its own dedicated Spring diagrams.  Developers can see these dependencies by using the Spring Beans or Spring Model Dependencies diagram. For runtime beans, developers can use the new Diagram Mode and see those dependencies.

The runtime feature for accessing HTTP request mappings from the editor has been upgraded. Developers can now manage the HTTP request mappings from Run Dashboard. This can be run straight away or opened in an editor-based REST client. There’s even an additional option to open HTTP requests in the browser for GET methods.

Version control systems, Maven, and more

  • Version Control systems: Developers can invoke and resolve merge conflicts with the Resolve action; favorite branches added.
  • Maven: improved support so the IDE works with the latest version of maven-compiler-plugin version 3.7.0.
  • JSON: Now supports JSON scheme v4, v6, and v7
  • Support for multiple GitHub Accounts
  • Future releases of IDEA 2018 will come with the ability to specify the default directory for opening projects
  • Kotlin 1.2.40 is bundled into IntelliJ IDEA 2018.2 EAP
  • New icons!


Developers can download the first EAP build here. Feedback is welcome.


Update May 9. 2018

No longer just for early access, Intellij IDEA 2018.1.3 is now properly released and available for download. We already went over a lot of what’s in this release (see below), but let’s take a look at what else this stable update has to offer.

Probably the biggest thing we haven’t already covered is the update for the built-in JRE. Switching to 1.8.0_152-release-1136-b38 has a number of benefits, including:

  • Bugfixes for a whole group of related issues for the broken Z-order of child windows  JRE-692JRE-695JRE-705.
  • It is now possible to disable IME via the JVM property: -Dawt.ime.disabled=true : JRE-729.

There has been a lot of work on improving performance for Spring, making it easier to open and update Spring diagrams.

Additionally, there was a lot of bugfixes for the search and replace. Now, the Find in Path shortcut is working again for the preview window.

Plus, users can turn on support screen readers with – JVM option. Simple add a it to the file before the first launch of a program.

For more information, please check out the release notes for the full and complete list of IDE fixes and JRE fixes.



Update April 27, 2018

Intellij IDEA 2018.1.3 EAP is now ready and available for download! What’s going on in this new release for the stable version? A whole lot of bugfixes, to be honest.

First off, IntelliJ IDEA 2018.1.3 EAP automatically checks for compatibility with your Kotlin plugin if you’re importing settings from previous versions. Additionally, if the imported Kotlin plugin isn’t comparable with this version, then it will use a bundled Kotlin version instead.

Other changes include support for very long names, especially in the Run/Debug configuration drop-down menu. No need to use abbreviations – IntelliJ IDEA 2018.1.3 supports 80 symbols by default.

IntelliJ IDEA also comes with improved Gradle support:

  • Gradle projects that use composite builds can now succeed when the build action is delegated to Gradle: IDEA-190088.
  • The navigation is fixed from the result in the Run/Debug view to the editor for JUnit5 test: IDEA-190103.

Finally, IntelliJ IDEA has also integrated a new JDK version. This comes with a few bugfixes of its own, including a possibility to disable IME via a JVM property, and an issue with IME window position of HiDPI screens.

For more information, check out the release notes for the IDE and JRE to get a full look of everything that has changed.



Update April 13, 2018

IntelliJ IDEA 2018.1.1 is herere! This is the first bug-fix update for the recently released IntelliJ IDEA 2018.1. We’re fixing a lot of bugs in this release, from automatic updates to saving keystrokes.

The biggest problem on the docket: automatic updates. Initially, “automatically check for updates” was set to disabled by default (IDEA-189445). Now, you can make sure your version is up to date without needing to go to the settings.

IntelliJ IDEA 2018.1.1 now comes with support for annotationProcessorPaths option in the maven-compiler-plugin 3.5 for external dependencies. It also updated the bundled Kotlin plugin to v1.2.31


  • Keystrokes are not lost during freezing (IDEA-186636)
  • Clicking the Replace all option from the Replace in path dialog doesn’t cause the IDE to freeze (IDEA-188229)
  • We’ve fixed the issue with broken JPS that inhibits all non-gradle Android builds (IDEA-189170)
  • Facet settings stored externally are now loaded by the build process (IDEA-189112)
  • Performance for scrolling huge text file on 4K monitors was improved (JRE-584)
  • The issue with AWT popups, which were above other process windows after alt-tab, was fixed (JRE-695)


Update March 28, 2018

IntelliJ IDEA 2018.1 is JetBrains’ first major update of 2018. It brings a lot of improvements to supported languages, frameworks, version control tools, debugger, compiler, and editor.

We’re going to focus on some of the most important highlights presented in this blog post but if you want to see the full list of fixes, check out the release notes. Don’t forget to download IntelliJ IDEA 2018.1 from the JetBrains website or get the update from the Toolbox App.

What’s new in IntelliJ IDEA 2018.1


  • Completion in the Stream API chains is now aware of type casting, which means it can suggest a completion item according to the existing call filter (String.class::isInstance), and also for an automatically typecast completion item.
  • The data flow analysis can now track the relationships between variables like “greater than” and “less than.” Furthermore, the IDE also detects when a condition is always true (or false) in all the possible code paths when the variables are compared.
  • The new Java 9 inspections and quick-fixes will come in handy because the IDE checks that a service loaded by ServiceLoader is declared in the file, and offers a quick-fix to add a missing statement to the module-info.javafile.
  • If there’s an unresolved class mentioned in, the IDE will suggest creating the missing class, as well as missing exported packages.
  • There’s a new Fix partially button which appears when you have several options for fixing possible problems in the chosen scope. You’ll find all the suggested quick-fixes grouped under the Fix partially button.
  • Support for the JUnit5 @Tag annotation has been added, which means you can include tagged classes and tagged methods, in the testing scope. All you have to do is select the Tags (JUnit 5) option in the test kind field in the Run/Debug Configuration dialog. Make sure to use the Uniqueld field to filter tests according to their id.

JVM Debugger

  • There’s a new Throw Exception action. This means you can throw an exception from a certain location in your program without changing the code. You’ll find it in the Run | Throw Exception menu, or in the frame context menu during a debugging session.
  • You can now print breakpoints stack traces to the console — this option can be enabled in the Breakpoints dialog box.
  • Furthermore, you can now copy the current thread stack trace via a new Copy Stack action.
  • JetBrains has extended the Async stack traces feature, which means you can now use the @Async.Schedule and @Async.Execute annotations to set up capture points that are not included in the default configuration. All you have to do is add Maven artifact as a dependency.

Java Compiler

  • The new Use –release option for cross-compilation (Java 9 and later) checkbox on the Java Compiler page [you can find it here: Preferences | Build, Execution, Deployment | Compiler | Java Compiler] is enabled by default. You can, of course, disable it whenever you need to use the –source and –target options with Java 9 and link against Java 9 classes at the same time.
  • You can use a specific version of the ECJ compiler. You’ll have to select Eclipse from the Use Compiler drop-down menu and specify the path to jar with the chosen compiler.


  • Good news! If there are any issues that have been detected in your code, the IDE now highlights the folded code regions that contain errors or warnings, and colors such blocks according to their validation status.
  • Speaking of folded code, the IDE also highlights folded code regions if they contain any matches when you search through the current file.
  • You can now see the automatic inferences of @NotNull or @Nullable annotations right in your source code. You’ll have to enable the Show inferred annotations inline checkbox here: Preferences | Editor | General | Appearance.


  • You’ll notice that, in the Project Tool Window, you can paste a code fragment directly into a package, and a new Kotlin file with the pasted code will be created.
  • The Kotlin Plugin offers new intentions which convert the scoping function calls let and run into each other, as well as also into apply and vice versa.


  • You can now annotate every groovy class in the scope with the @CompileStatic annotation [available in the context menu Refactor | Convert to @CompileStatic].
  • IntelliJ IDEA 2018.1 also reports unnecessary import alias for Groovy files.


The changes from Android Studio 3.0 have been merged, which means there are a lot of new features, including:

  • Android Profiler, a new suite of profiling tools that provide real-time data for your app’s CPU, memory, and network activity.
  • Device File Explorer Tool Window shows the file and directory structure of your Android device or emulator. If you want to view, copy, and delete files on an Android device, this tool window will come in handy. You’ll find it in View | Tool Windows | Device File Explorer.
  • The Layout Editor has been improved.
  • You can now build Instant Apps – lightweight Android apps that can be run without installation. However, you’ll have to make sure the Instant Apps Development SDK is installed.

Spring Boot

  • 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. If you want 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, go ahead and click the icon.
  • All the beans that are registered in the application context can be seen in the Beans tab in the Run Dashboard (or in the Run Tool Window). In IntelliJ 2018.1, this information is also available in the editor.

JavaScript & TypeScript

  • The latest TypeScript 2.7 features are now supported.
  • The Implement Members action has been improved.
  • You can create a new Vue project with the Vue.js plugin. To install Vue CLI, run npm install –g vue-cli in the terminal.


  • 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.
  • The plugin shows all the existing Compose projects.


  • The new Kubernetes plugin supports the Kubernetes resource files from v1.5 up to v1.9 [latest release]. It looks 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.
  • Rich support for the YAML Kubernetes resource files: If you type the required key and invoke Smart Completion, the new plugin will auto-complete all the required keys from all the levels below.
  • There’s a built-in Live Template that allows you to quickly create the type of YAML Kubernetes resource file that you need. There are a few predefined Kubernetes templates, and you can invoke the necessary Live Template by typing its abbreviation.
  • Furthermore, the Kubernetes plugin will alert you whenever you select deprecated Kubernetes properties.
  • There’s also some support for JSON Kubernetes resource files based on the JSON schema functionality
Inline Feedbacks
View all comments