Early Access Program

IntelliJ IDEA 2018.3 Goes Beta

We are happy to announce that IntelliJ IDEA 2018.3 Beta is now available for download! This is the perfect time to summarize all the amazing new features that are coming in the next major update this fall. They include 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! Let’s have a look at these and the dozens of other notable features in detail.


Better navigation over the project and IDE
Run Anything
Reworked Plugins Preferences Page
New Structural Search & Replace dialogs
JVM Profiler
Version Control Systems
Accessibility improvements
JVM Debugger
Run Configuration

Better navigation over the project and IDE

Even the best features can sometimes need an update, so on that note, please let us introduce the new and improved Search Everywhere dialog. The reworked dialog now 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). Each of these now has its own separate tab in the new dialog, and you can use the TAB button to switch between these tabs. Of course, all of the navigation dialogs are still accessible through their original keyboard shortcuts, as before.


Run Anything

Have you already tried the new universal action called Run Anything (Double Ctrl)? It’s a new unified way to run any and all commands in IntelliJ IDEA. You can now launch any run configuration, including Maven and Gradle run configurations, or run a Gradle task. You can even use it to run terminal commands.


It’s now even easier to debug a configuration of your choice. Simply press the Shift key to switch the dialog to the Debug Anything mode.


Reworked Plugins Preferences Page

It is also time for a change for the plugins preferences page. We have made it easier to manage all the existing plugins, and to search for and install new ones.

Now you can search for plugins by categories, and sort the search results by the number of downloads, rating, or update date. You can also view all the new and updated plugins, the top downloaded plugins, and the top-rated plugins from inside the IDE.

Easily find the plugins that need updating, as the IDE will display such plugins in the dedicated Updates tab.

The IDE will now show you all the downloaded and bundled plugins separately under the Installed tab.


New Structural Search & Replace dialogs

IntelliJ IDEA 2018.3 Beta delivers an updated and streamlined Structural Search & Replace dialog. Now autocompletion works in the predefined templates in the search field. You can view the search history in the drop-down menu under the search icon. Scope configuration is now easier and more flexible, too. You can edit variables/filters right from the Structural Search & Replace dialogs. Finally, the complicated Edit Variables form has been replaced with a filters panel, which you will find in the updated dialog.


JVM Profiler

IntelliJ IDEA 2018.3 Beta Ultimate edition comes with a JVM Profiler integration on Linux and macOS. Windows support is planned for later in 2019.

The IDE includes a low overhead sampling profiler – Async profile. You can now view the native parts of the execution stack, profile memory allocations, show Flame Graphs, and more.

To start profiling a Java (or Kotlin) run configuration for IntelliJ-based projects, use the profiler icon from the main toolbar. Please note that Gradle and Maven projects are not supported.

The profiling results will display in the CPU Profiler tool window (View | Tool Windows | CPU Profiler).


Please note that if you are on Linux, perf is required to run profiling in IntelliJ IDEA. You should install perf for the particular kernel version you have. In addition, you should allow perf to collect information without root privileges for the set
`/proc/sys/kernel/perf_event_paranoid` to 1
and `/proc/sys/kernel/kptr_restrict` to 0.

Version Control Systems

GitHub Pull Requests

The wait is over! The upcoming IntelliJ IDEA 2018.3 brings with it the much anticipated initial support for GitHub pull requests. Now you can view all the pull requests from your GitHub repository as a list from right inside the IDE, thanks to the brand new GitHub Pull Requests tool window. Just select VCS | Git | View Pull Requests from the main menu to get started.

We have even made it possible to create a new local branch from a pull request by right-clicking on it and then merging it as a regular branch.


Git submodules support

Another exciting new feature in IntelliJ IDEA 2018.3 Beta is its support for Git submodules! Now IntelliJ IDEA will clone the root repository and all its submodules when you make a clone of a repository that has submodules.

When you update such a project, all the submodules will now be correctly updated according to their state. Of course, all the goodies such as Diff, History, and Conflict resolution work for submodule folders too.

Advanced navigation in VCS Log

You can now use the Forward and Back navigation actions in more places than before: while you are in the VCS Log, after you navigate from the commit hashes to the commit in the VCS Log tab, or after you use the ‘Go to hash/branch/tag’ action (Cmd-F on macOS, Ctrl-F on Windows and Linux). You can either use the Cmd-] / Cmd-[ shortcuts, or choose these actions from the main menu: Navigate | Back / Forward.


Speaking of navigation in the VCS Log, you can also use the left and right arrow keys to go to the child or parent commit. These new actions work nicely with merge commits as well.

The IDE can now display the full history of a file, including all the branches and the history up to the current point. Choose ‘History Up to Here’ and then toggle the ‘Show All Branches’ icon on the toolbar. (Previously, the IDE only showed the file history up to the selected commit, and if the file was deleted in some commit after, it was no easy task to find out about such an occurrence.)


Improved Annotate support

It’s now easier to work with the Annotate feature in IntelliJ IDEA. The IDE allows you to ignore whitespace changes while you annotate. The Annotations context menu includes a new Ignore Whitespaces option, along with other options such as code movement detection. Please note that the Ignore Whitespaces option is enabled by default.


Moreover, it is possible to invoke the Show Diff for an Annotated line by using the keyboard. Press Ctrl-V on macOS or Alt-` on Windows and Linux to invoke the VCS Operations pop-up, and then select Annotated Line | Show Diff.

And more improvements for version control systems

It’s now possible to ignore whitespace changes while merging. There is a new Ignore drop-down menu with options to hide or trim whitespace changes on merge in the Merge Revisions for… dialog.


In IntelliJ IDEA 2018.3 Beta, you can easily copy a file from one Git branch to another: use the new Get from Branch action in the Files tab of the Compare branches dialog.


It is also possible to view the branch name you are committing the files to, right inside the Commit dialog. The good news is – we have implemented it for Git, Mercurial, and SVN.


We’ve also added a Diff Preview to the File History tab of the Version Control tool window.


It is also worth mentioning that IntelliJ IDEA 2018.3 now updates Git multi-repository projects significantly faster. Now, the IDE fetches all your Git repositories in the project in parallel during a project update, rather than one by one as it was before.

Now the IDE also uses the Native Git SSH Executable by default. It will correctly handle the passphrase and other prompts from the native SSH.

Committing from the IDE now respects Git Hooks that add additional files to the commit. Previously, such files would be left uncommitted, but now the IDE includes them in the commit.

Accessibility improvements

We are devoted to providing a great experience for all of our users, and with the upcoming IntelliJ IDEA 2018.3 we have some notable accessibility improvements. One of the key changes is the new High Contrast theme, which you can switch to in Preferences (Settings) | Appearance and Behavior | Appearance.

We intend to continue our work on making IntelliJ IDEA even more accessible in the future and we highly appreciate your non-stop feedback! Keep it coming!


Accessibility inspections for HTML

To help write more accessible HTML code easily, we’ve added loads of new inspections that are based on recommendations from the Web Content Accessibility Guidelines 2.0 (WCAG) developed by W3C.

You can locate the whole list of new inspections in Preferences / (Settings) | Editor | Inspections | HTML | Accessibility.



Multiline TODO comments

Another welcome change for IntelliJ IDEA 2018.3 Beta is multiline TODO comments! Now the first and all subsequent TODO comment lines are highlighted in the editor and listed in the TODO Tool Window. Simply add an indent starting from the second line of your multiline TODO comment, and the IDE will differentiate it from an ordinary comment.


New indentation status bar

IntelliJ IDEA has a new indentation status bar that displays the size of the indent in the current file. You can now choose actions that control the current indentation right from the status bar popup.


Disabling code formatting for specific files and folders

We’ve made it possible to lock certain files from formatting, imports optimization, and code rearrangement – actually from any operations where formatting is involved, explicitly or implicitly. You can simply create a scope and add any files which should not be formatted in Preferences (Settings) | Editor | Code Style from the “Formatter Control” tab. After that, the IDE will give a notification with the “Show settings…” action link which navigates you to the “Formatter Control” tab of Preferences (Settings) | Editor| Code Style, if you try to perform reformatting on files with where formatting is disabled. By the way, the same occurs for selected fragments of code.


Navigate between editor tabs via a custom shortcut

You can now navigate straight to VCS the editor tab you need via a shortcut ( tab1, tab2, tab3…tab9 or just straight to the last tab). Please bear in mind, that there are no default shortcuts for these actions, however, you can assign your own shortcuts in the Preferences / Settings | Keymap | Other.


Search for multi-line fragments in Find in Path

It’s possible to now perform search / replace for a multi-line fragment in Find in Path / Replace in the Path dialogs. You no longer need to use regular expressions as a workaround to perform a multi-line search.


JVM Debugger

Ability to attach to java processes started without debug agent

Let’s take a look at the enhancements we’ve made to the JVM debugger for the upcoming IntelliJ IDEA 2018.3. First of all, now you can attach to Java processes that were started without a debug agent. All the processes that are available for attaching are listed in the “Attach with Java Debugger To” action list. Just a quick heads-up, the processes have to be started with JDK, and not JRE. After you’ve attached to a process you’ll be able to view the current thread’s state, variable values, and use the memory view.


Support for async stack traces in Remote JVMs

IntelliJ IDEA 2018.3 Beta supports async stack traces in remote JVMs. To start using the agent remotely:

  • copy /lib/rt/debugger-agent.jar to the remote machine.
  • add -javaagent:debugger-agent.jar to the remote JVM options.

Ability to define async annotations

You can now define your own async annotations, using Async.java as a reference. Go to Preferences/Settings | Build, Execution, Deployment | Debugger | Async Stack Traces, click the ‘Configure annotations’ button, and then add your own custom async annotations to the Async Annotations Configuration dialog.


New Auto restart option for the remote debug configurations

Another feature that you could benefit from is the new ability to restart a configuration automatically, while you are debugging a remote process. Simply enable the new ‘Auto restart’ option for remote debug configurations.


Shortcut to remove all breakpoints

With the forthcoming IntelliJ IDEA 2018.3, we have introduced some new handy actions that remove all the breakpoints in a project, or all the breakpoints in the file. These new actions are available through the ‘Find Action’ (Cmd-Shift-A on macOS / Ctrl-Shift-A on Windows and Linux). Alternatively, you can assign your own shortcut in Preferences (Settings) | Keymap | Debugger Actions.



IntelliJ IDEA now displays duplicates in the diff viewer, so you can compare them side by side in the Duplicate detector tool window. The IDE can now detect duplicates in more complicated cases, even if the variable names are different, and it does this faster as well.


The Diff preview for comparing duplicates is also available in the Inspection Results tool window. So, when you have multiple files with duplicate code, you can use the drop-down menu to select the required file.


As you have probably already come to expect, the new version of IntelliJ IDEA comes with loads of new Java inspections and quick-fixes.

Improvements are coming to our support for the Java Stream API. Now the IDE can spot cases where unnecessary sorted calls are made before the subsequent min call. It provides a quick-fix to remove the redundant sorted call, as a min call doesn’t depend on the sort order.


The nullability analysis for stream chains now checks against element-level nullability annotations: toArray(), toList(), and toSet() collectors are supported. A Method reference is also supported if the method nullability can be inferred or explicitly specified.


IntelliJ IDEA 2018.3 comes with data flow enhancements. In IntelliJ IDEA 2018.3 we have created a data-flow-based inspection called “Condition is covered by further condition” which detects situations where the first condition is unnecessary as it’s covered by the second check. This inspection also has an extra relation check between three variables which can be deduced from the transitivity.


The IDE detects cases where arguments of methods have the same value when it doesn’t make any sense. The reported methods include Math.min, Math.max, and String.replace. This is part of our data flow analysis which not only detects and reports simple cases like Math.min(a, a), but also more complicated cases like if(a == 100) return Math.max(a, 100).


IntelliJ IDEA provides the ability to remove static import with * and add qualifiers to the usages in the code instead.


The IDE now highlights in the editor redundant usages of the @SuppressWarning annotation, or // noinspection line comment, or /** noinspection */ JavaDoc comment. When a suppressed inspection no longer addresses any warnings in the associated method body, class, or statement, the IDE will not only warn you, but will also provide a quick-fix to remove such unnecessary annotations and comments.


Run Configuration

Support for macros in Java run configurations

With this update, we are going to deliver a couple of useful features that relate to Run Configurations. Let’s start with one that is in quite popular demand: you can now use macros in run configurations. You can enter one of the predefined macros in the Program arguments field. For now, the IDE only supports the “Application” and “npm” run configurations.


Ability to use text files as input

If you want to use a text or log file as input, simply select the ‘Redirect input from’ option in the Run/Debug Configurations dialog, and then specify the path to the file that has your input data.


Run configuration is run as a single instance only, by default

A run configuration is now run as a single instance only, by default. However, there is the ‘Allow running in parallel’ option in the Run/Debug Configuration dialog which you can enable if you ever want to run several instances of the same run configuration in parallel.



A while ago we made it possible to delegate all the build and run actions to Gradle. Now, it is possible to delegate all your build and run actions to Maven. Go to Preferences / Settings | Build, Execution, Deployment | Build Tools | Maven | Runner and select the new ‘Delegate IDE build / run actions to maven’ option.


The Kotlin plugin bundled with the IDE has been updated to v1.3 RC4. Loads of bugs have been fixed – learn more here.


  • Better JPA and Spring Data support for Kotlin. Learn more here.
  • Spring MVC now speaks Kotlin.
  • SpEL language support.
  • Spring Boot v2.1 support.

More details are coming, so stay tuned!

Docker integration

Please note that we’ve bundled the Docker integration plugin. We also support CLI options for the build part in Docker run configurations.

JavaScript & TypeScript

  • Support for TypeScript 3.1
  • Better null and undefined checks in JavaScript and TypeScript
  • Auto-import in JavaScript files now works for symbols from the project’s dependencies
  • Parameter name hints in JavaScript files
  • Improved Remove tag action for HTML and JSX
  • Lots of improvements in coding assistance in Angular templates, including much better support for pipes, template reference variables, and ngFor
  • Debug linked npm modules
  • Support for multiline todo comments in CSS, SCSS, and other stylesheet files
  • Convert a function to a variable holding an arrow function, with a brand new intention action
  • Linting TypeScript files with ESLint
  • Option to use a custom severity level for linters
  • Run a single Protractor test or suite

You can find more details about this and some other notable features in the WebStorm blog.

Kubernetes plugin

We have enhanced the Kubernetes plugin with rich Helm support! Coding assistance, including code completion, rename refactoring, inspections, and quick-fixes, now works with Helm resource template files. You can also preview the result of the Helm template in the diff viewer, or execute helm dependencies on the chart with the “Helm Update Dependencies” action. Not to mention advanced navigation… For more details and screenshots, please refer to this blog post.


  • Support WebLogic deployment plans and installing artifact as a library
  • Support Jetty 9.4.x
  • Support OpenShift Origin (V3) and token authentication

Miscellaneous changes

In other news, IntelliJ IDEA 2018.3 Beta brings a native menu bar to Linux.

The GTK (on Linux) and Windows native themes have been removed.

You can view how much CPU the subsystems and plugins (both built-in and additionally installed) are consuming by utilizing the brand new Activity Monitor which is available from main menu | Help | Activity Monitor. The Activity Monitor arranges the subsystems, categories, and entries in the list by how much %CPU they are currently using. Please note that it’s an experimental feature for now.

You can now simply drag the folder to the Welcome screen to open it in the IDE.

Did you know that IntelliJ IDEA 2018.3 Beta supports batch mode update for sequential updates? Now when sequential updates are available, IntelliJ IDEA will chain them and patch itself in a single pass.

Whew! That just about does it! You can find the release notes for IntelliJ IDEA 2018.3 here, if you want to check out the release notes for the build use this link.

We hope that you’ll enjoy all the goodies that IntelliJ IDEA 2018.3 Beta has to offer. If there are other improvements you’d like to see, please leave a comment below, create an issue in our issue tracker, or tweet at us!

Happy Developing!

image description