Keeping track of IntelliJ IDEA 2018's progress

IntelliJ IDEA 2018 progress report: 2018.1.5 is here

JAX Editorial Team
IntelliJ IDEA 2018.1

© Shutterstock /Vector Goddess

Time to check in on IntelliJ IDEA 2018! The IntelliJ IDEA 2018.1.5 is now available! This update is something of a bug fix and targets a number of unpleasant regressions. We take a look at what else this update has in store for developers.

Updated June 15, 2018

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

Leave a Reply

Be the First to Comment!

Notify of