2016.3 Nov 22

JVM debugger

Class-level watches

Now you can define watch expressions on the class level. These watches appear as extra fields of the class but are evaluated based on your expressions. An expression for class-level watches is defined in the context of the class.

Primitive type renderers

Now you can define custom Java Type Renderers for primitive types too, including arrays.

Memory view

With the help of the new JVM Debugger Memory View plugin you can explore objects in the JVM heap during a debug session.

When you’re stepping over the code, the Diff column shows you how the number of objects changes between debugger stops. A double click on a class name, opens a dialog with instances of the class. If needed, the plugin is also capable of tracking stacktraces for chosen classes.

Detecting JRE

Also, the debugger got better at detecting JREs used by the running application. Now, if the application uses a JRE different from the project JDK and you’re stepping into the JDK sources, the IDE will try to use another JDK configured in the IDE that better matches the running JRE version.

Version control

Log for Git & Mercurial

  • Search speed has improved dramatically, particularly for the Text, Author and Path filters.
  • Commit details have moved to the right, giving more space to the Log itself.
  • Commit messages in the table are now aligned and thus more readable.
  • Labels have been moved to the right side and are now displayed in a more elegant way.

Resolving conflicts

Now, the IDE is capable of resolving simple conflicts. When such a resolve is possible, the IDE shows a Resolve icon on the left side of the editor. Click the icon to have the conflict resolved by the IDE. To undo, press Ctrl+Z.

Syntax highlighting in the Diff and Merge dialogs

We've added full syntax highlighting for non-local revisions in the Diff and Merge dialogs.

To get it working, we’re building the PSI tree rather than relying on lexer tokens. As a nice side effect you get code navigation here as well.

Line markers in the Merge dialog

Also, we’ve added line markers to the Merge dialog to indicate actual changes to the base revision.

This makes it easier to understand what changes are actually going to be applied.

Undo commit

Now you can undo your last change (that you haven't yet pushed) in one click via the Log's context menu.

Restore and Delete tracked branch actions

Now, when you delete a local branch, you get a notification that lets you quickly undo it or delete the tracked remote branch too.

Sign-off commit

The Commit Changes dialog allows you to sign-off your commit. This may be a requirement for getting patches into some projects (including the Linux kernel).

Managing Git remotes

We’ve added a way to manage Git remotes: via VCSGitConfigure Remotes. Now you can add, edit and remove remotes for every repo in the project.

Note that adding a remote is also available in the Push dialog.

User interface

Parameter hints

The editor now shows parameter hints for literals and nulls used as method arguments. These hints make code much more readable.

If you find hints redundant for a certain method, you can tell the IDE not to show hints for this method. To disable hints completely, uncheck SettingsEditorGeneralAppearanceShow parameter name hints.

Semantic highlighting

Semantic highlighting, previously introduced in KDevelop and some other IDEs, is now available in IntelliJ IDEA. It extends the standard syntax highlighting with unique colors for each parameter and local variable.

To enable this feature, check SettingsEditorColors & FontsLanguage DefaultsSemantic highlighting.

Flat file icons

In this update we've reworked the file icons to achieve a flatter design. While the new icons may look unusual, hopefully they feel sharper and less noisy to you.

Later, we may introduce flat icons to other parts of the IDE as well.

Recent tests

Now you can press Shift+Ctrl+; and get a popup with recent tests. The popup shows successful test configurations and failed individual tests. Press Enter to re-run the selected test or F4 to navigate to its declaration.

Resource bundle editor

The Resource Bundle editor now shows you which properties are unused in the project.

Find in path settings

Previously, the Find in Path dialog would reset some of its settings if you called it from the Editor. This behavior didn't seem convenient so we've changed it. Now the dialog always preserves previous settings independently of where you call it from.

Fira Code font

Another font-related change, now affecting all platforms, is Fira Code which is now bundled with the IDE and allows everyone to use Font Ligatures.

SF font for macOS

macOS users will notice that the default font of the UI (SettingsAppearance & BehaviorAppearanceUI Options) has changed to San Francisco (in particular SF NS Text), now the standard for the macOS platform.


Refactoring to Java 8

Now, if you press Alt+Enter inside a non-trivial for-loop, the IDE will prompt you to replace it with a chain of stream API calls. It supports count, flatMap, map, mapToInt, collect, filter, anyMatch, and other Stream methods. learn more

Also, when appropriate, the IDE will prompt you to replace certain code with Map.computeIfAbsent, Collections.removeIf or ThreadLocal.withInitial. learn more

Reporting nullability issues

Now, if you have a method with a @NotNull, Objects.requireNonNull or Guava’s Preconditions.checkNotNull contract and the IDE notices that this contract is broken somewhere in the project, it will notify you immediately about that next to your parameter definition.

The corresponding inspection also allows you to navigate to those usages breaking your contract–so you can fix that.

Inlining local variables used only by return statements

The new inspection finds local variables used only by return statements, and provides a quick fix that inlines these variables–by replacing their assignments with return statements.

When the returned value can’t be inlined into a return statement, the quick fix attempts to move the return statement as close to the computation of the returned value as possible.

learn more

Runtime assertions for not-null-annotated code

IntelliJ IDEA’s compiler (SettingsBuild, Execution, DeploymentCompiler) has an option to generate runtime assertions for methods and parameters annotated with org.jetbrains.annotations.NotNull.

Starting now it supports non-JetBrains annotations as well, in particular JSR-305.

learn more

Some intentions became quick-fixes

Unlike intention actions, inspection quick-fixes can be applied to many files at once. We've chosen several intentions that may work better as quick-fixes and converted them: Lambda can be replaced with anonymous class and Diamond can be replaced with explicit type arguments to name a few.

Lambdas in Structure view

Now if you press Ctrl+L in the Structure view, it will show lambda expressions.

Unused declaration options

Now you can manage the Unused declaration inspection by choosing which members to report.

learn more

Meta-annotations hierarchy

The Type Hierarchy view now works for meta-annotations as well.


Loop to Lambda Conversion

The Kotlin plugin can now detect many non-trivial cases where imperative for loops can be rewritten in a more compact and idiomatic manner using standard library functions such as filter, map, flatMap, count, etc. To trigger the conversion, put the caret on the for keyword and press Alt+Enter.

New Refactorings

The Kotlin plugin now supports Extract Interface and Extract Superclass refactorings, as well as an entirely new refactoring Introduce Type Parameter, providing an easy way to change a class or function into a generic one.

Postfix Completion

IntelliJ IDEA’s postfix code completion is now supported for Kotlin, with a large array of templates.



We’ve added better support for js.Dynamic. The Scala plugin now provides code completion and quick navigation to fields and methods defined in JavaScript libraries or project files.

learn more


Another major plugin improvement is the support for scala.meta. IntelliJ IDEA supports new-style macro annotations and provides coding assistance for scala.meta quasiquotes.

learn more


The plugin now suggests actor constructor parameters in Akka’s Prop method (Ultimate only).


Last but not least, we’re working on a new “Migrators API” that will allow library authors to tell IntelliJ-based IDEs how to migrate of projects that are using different library versions. This will make it possible to automatically migrate code, replace certain APIs, and so on. The plugin uses this API itself for providing migration of code to Scala 2.12, e.g. replacing it with SAM. Available migrators can be enabled via SettingsLanguage & FrameworksScalaMigrators.


We’ve added actions that build Groovy files located in resource folders. They’re available via the main menu BuildGroovy Resources. Build Resources is incremental while Rebuild Resources builds from scratch.


Delegate IDE build/run actions

We’ve added an option that delegates the native IntelliJ IDEA actions Build, Build Artifacts (both WAR and EAR) and Run to Gradle. Select SettingsBuild, Execution, DeploymentBuild ToolsGradleRunnerDelegate IDE build/run actions to gradle.

When this option is enabled, all these actions are performed via corresponding Gradle tasks.

learn more

Composite builds

For Gradle 3.1 and higher, we've added support for Composite Builds, so you can substitute any of your project dependencies with another project.

All you have to is to attach the Gradle projects of these libraries via the Add button in the Gradle tool window (my-utils in our case), and then select Compose Build Configuration from the context menu for the original project.

learn more


The added support for Polyglot Maven allows you to write the POM file in any language, including Groovy, Scala, and even Ruby.

The Show Effective POM action works as usual and is especially useful if you want to see how Maven interprets the DSL.


Project Wizard

The layout of the Spring Initializr (Project Wizard) has been reworked to fit more items, and provide Search and additional information.

Meta annotations

We've added support for meta annotations based on @Autowired and @RequestMapping (including user-based and built-in annotations such as @GetMapping and @PostMapping).


Last but not least, we've improved the IDE's performance and responsiveness when handling large projects with numerous beans, regardless of whether they’re configured via XML descriptors or annotations.


The Grails view is back for Grails 3, as a tab inside of the Project tool window. All the Project tool window settings are now applicable to Grails, including Flatten Packages.

Items under the Plugins node (always the last in the list) navigate to the corresponding GrailsPlugin class.


In Spring Boot projects the Console now doesn’t require persistence.xml in the JPA facet. Also, the IDE now respects the naming strategies provided with Spring configuration files.

Support for queries has been updated according to the changes introduced with Hibernate 5.2.

Application servers


Loose applications now can be run from the IDE. To run a loose application, open the Deployment tab of your WebSphere Run configuration and select the loose application XML file, instead of an artifact.

TomEE 7

Support for TomEE has been updated to its major version 7.



Now, when you set JavaScript version to Flow, the IDE reports problems in files annotated with "// @flow" on the fly.

Make sure you've specified the installation path for Flow in SettingsLanguages & FrameworksJavaScriptFlow.

ECMAScript 6

Convert var to const/let

Now, the IDE reports all var declarations and help replace them with let or const declarations, depending on value semantics.

Replace require() with import

For all require() calls, the IDE now provides a quick-fix that replaces them with import statements.

Convert to class

The IDE can now convert complicated prototype chains into a hierarchy of classes.

Default exports

The Find usages and Show usages actions have been extended to support default-exported functions and classes.


Rename refactoring

When you rename a method that overrides or implements another method, the IDE now offers to rename the base method too.

If you choose to rename the current method only, the IDE makes sure to rename all methods that override the current one.

Optimizing imports

Also, we've added a new inspection that warns you when an import statement can be shortened, and provides a quick-fix to do that.

Angular 2

Templates coding assistance

Coding assistance within templates is now more precise and aware of available types.

Generating code

Now you can quickly generate components, directives, services, and other blueprints by pressing Alt+Ins and choosing Angular CLI from the Generate popup.


Integration with Protractor, an end-to-end testing framework for Angular apps, now lets you easily run and debug tests in the IDE and see test results in a tool window, with options to filter them and quickly jump to the test source.

React Native


Now you can run and debug React Native apps without leaving IntelliJ IDEA.

All it takes is a new React Native Run/Debug configuration. Just create one, select the target platform, and make sure that the path to the React Native CLI package is correct.


When working with React Native apps, IntelliJ IDEA will now provide code completion (and color preview) for properties inside StyleSheet.



IntelliJ IDEA now offers a plugin for PostCSS. The plugin provides code completion, formatting, navigation, inspections, rename refactoring, and more.


Stylelint, a code quality tool for stylesheets, is now integrated so that you can see errors reported by it right in the editor.


Blueprint mode

The new Blueprint mode in the Designer hides all of the visuals from views and shows only their outlines. You can choose to have it side by side with the Designer.

learn more

Constraint Layout

Constraint Layout is a new layout manager for creating large and complex layouts with a flat view hierarchy. It’s similar to Relative Layout in that all views are laid out according to relationships between sibling views and the parent layout, but it’s more flexible and easier to use.

learn more

APK analyzer

The new APK Analyzer lets you drill into your APK to help you reduce your APK size, debug 64K method limit issues, view contents of Dex files and more.

Instant run

This release adds many stability and reliability improvements to Instant Run. If you have previously disabled Instant Run, the Android team encourages you to re-enable it.


Editing multiple cells

Now you can edit several similar cells at once. Select several cells and start typing a value. If you need a cell editor (e.g. a Data Chooser), click Enter.

Submitting changes in bulk

Now changes made in the Table Editor are stored locally and submitted in bulk, via Ctrl+Enter.

Changes not yet submitted can be canceled via Ctrl+Z.

Finding usages

Now you can find usages of objects inside the source code of other objects. For instance, you can learn in which stored procedures, functions or views your table is used. As usual, press Alt+F7 on the table name or call it from the context menu.

Editing triggers

Triggers now can be edited for MySQL, PostgreSQL, SQL Server, Oracle and Sybase.

Local changes

Now when you edit the source code of any object, the IDE tracks your changes and highlights edited rows in the left editor panel. If you click on a highlighted row, a small toolbar is displayed with a Show Diff link.

Executing large scripts

If you run large script files from the context menu, you'll notice that now they are executed much faster.

Coding assistance

Now if you use JOIN USING for Postgres, the IDE offers you only the field names common for both tables.

The INSERT statement completion offers you not only the list of all fields but also the list of fields which have no default value.

If a variable or parameter is not used within its scope, you'll get a warning.

You'll also get a warning if there is a mismatching number of columns in queries used in set operators (UNION, INTERSECT and EXCEPT).

Integration with mysqldump and pg_dump utilities

We've integrated the IDE with the mysqldump and pg_dump utilities. To use the utility, choose the Dump with… option from the context menu.

Introspect schema/database

Now, when you access a schema or database not introspected by the IDE yet, it will provide a quick-fix for that.

Managing datasource driver

Now the IDE helps you manage the version of the datasource driver and update it if it's not up-to-date.

If want to use a particular version of the driver, choose it in the driver's settings. Also, you can uncheck Use provided driver and use only files added to the Additional list.


Google Cloud Tools

Google has introduced their own IDE plugin for deploying to Google App Engine. Eventually this plugin will replace the Google App Engine plugin provided by JetBrains.


On our side, we've updated the OpenShift integration with support for OpenShift V3. The updated plugin lets you create applications and manage their resources such as projects, services and pods.

2016.2 Jul 12


Watches and variables

The Watches view has been merged with Variables for more convenience.

Multiline expressions

Multiline expressions are now supported in breakpoint’s Condition and Evaluate and log, and Data Type Renderers.

Version control


The Log viewer for Git and Mercurial continues getting better:

  • It loads in the background on every change (a commit, fetch, rebase, etc). As a result, it’s always ready when you open it.
  • We’ve reworked the way the Log shows the loading progress. Now, when refreshing, there’s a thin stripe shown under the toolbar.
  • When you select several commits, you see all commit details.
  • Ctrl+L can be used for navigating to the Filter field.


A patch can be applied from the clipboard (when the IDE obtains focus), or by dragging a file into the IDE.

If a file has been moved or renamed since a patch was created for it, the IDE will try to figure that out or let you manually choose the file to apply the patch to.

In case the file has been changed since a patch was created for it, but IntelliJ IDEA cannot find its original revision, you'll be prompted to apply the patch using a Merge-like dialog.

Also, the Apply Patch dialog provides the Show Diff action to compare the patch to your local version. While comparing, you can edit your the local version.

Case-only renames

We've added support for case-only renames in Git for Windows and macOS.

Unversioned files

The Commit dialog shows unversioned files so you don’t forget to commit something important.


JUnit 5

The IDE update brings support for JUnit 5, the next generation of the most popular unit testing framework for Java.


The IDE warns you when you instantiate new objects inside equals, hashCode, compareTo or Comparator.compare methods.

User interface


We've added support for monospace font ligatures. To enable ligatures, go to SettingsEditorColors & FontsFont, choose a font that supports ligatures, e.g. FiraCode, Hasklig, Monoid or PragmataPro and select Enable font ligatures option.


Until now breadcrumbs were only available in HTML and XML code. Now breadcrumbs work for Java, too, where instead of tags they let you navigate through classes, lambda expressions and methods.

Inspections tool window

The Inspection tool window has been redesigned for better ergonomics: now the code location for each problem is displayed, along with controls to apply a quick-fix or suppress the inspection.

Background images

Also, we’ve added a new action called Set Background Image. Give your IDE a custom look by choosing a background image for the editor and the IDE frame.

The action is available via Find Action and, for a selected image file, via the context menu for the Project tool window and Image Editor.


We've reworked the way IntelliJ IDEA displays notifications to make them a little bit more friendly: the popups are now displayed in the right-hand bottom corner (next to the Event Log tool window icon), more compact, and grouped by the subsystem they came from.

Spring Frameworks

Spring Core 4.3

  • A quick-fix suggesting to replace field injection with a constructor injection.
  • Generic types as qualifiers.
  • EventListener meta annotations defined with @AliasFor.
  • Highlighting and navigation for Spring messages in Console.
  • Better performance.

Spring Caching

  • Support for CacheResolver, CacheManager and KeyGenerator components.
  • An inspection that ensures that a cache name is provided for cache-related operations.
  • An inspection that warns you if you use Caching annotations on interfaces.
  • An inspection that warns you if you use CachePut and Cachable with the same method.
  • Support for Cachable meta annotations defined with @AliasFor.
  • Context dependent assistance for editing SpEl in annotations.
  • A gutter icon for navigating to other operations related to the same cache name.

Spring MVC

Code completion and navigation within FreeMarker or Velocity templates for defined variables.

Spring Security

  • Support for all major features added in Spring Security 4.0.
  • Context dependent assistance for editing SpEl in annotations and XML.


ECMAScript 6

The IDE now helps convert callback functions to arrow functions when you click Alt+Enter on the function keyword. Also, it can convert arrow functions to shorthand arrow functions.

Postfix completion

In addition to the .var postfix template, added earlier, now you can use .let and .const templates. As you might guess, when you press Tab these expand into declarations with let and const keywords.


The IDE can now understand component properties defined via propTypes and provides code completion for them.

The component lifecycle methods (e.g. componentDidMount, etc) aren't shown as unused anymore.

Another nice improvement is that now IntelliJ IDEA will automatically add {} instead of “” for React events like onClick, onChange, etc. Moreover, the IDE now understands React non-DOM attributes: key, ref and dangerouslySetInnerHTML.


We’ve added a collection of Live Templates for Angular 2. To use a template, type its abbreviation in the editor and then press Tab to expand it. Press Tab again to jump to the next edit location in the template.

Also, the Project Wizard now supports Angular CLI.

Npm, Grunt and Gulp

Now you can specify any Grunt, gulp or npm task as a Before launch task in a Run/Debug configuration.

HTML code style

Now you can configure whether you want the IDE to add single, double or no quotes at all when autocompleting attributes in HTML and JSX.


The update brings support for TypeScript 2.0 features: optional class members, readonly property, never type, this function type, global module export declaration, resolve for type declarations in @types folder, path mappings based module resolution, and more. Also, try smarter support for enums.

Database Tools

  • Code completion for database names in Data Sources and Drivers.
  • Auto-scroll from Editor option in the Database tool window.
  • Code completion is more relevant now: it doesn't suggest functions when a table name is expected.
  • Surround With now includes function.
  • Table Editor provides completion for column values.
  • Resizing columns via Ctrl+Shift+Right/Left.
  • PostgreSQL support has been extended to Schema Search Path, Range types and types with TimeZone.
  • Learn more…


The update includes the Android Studio 2.0 features: faster Emulator, experiment GPU Debugger, faster full builds, and code generation and testing for App Indexing. Note, Instant Run is not fully-merged yet.

2016.1 Mar 29


Groovy expressions

Now when debugging a Java application, you can use Groovy expressions with Evaluate Expression and Watches. Previously you could do that only when debugging Groovy code. This is good because Groovy expressions are much shorter and more expressive (especially when you work with collections).


Until now, stepping over one thread meant IntelliJ IDEA would also resume all the other threads. Now you can change this behavior by enabling the Resume only the current thread option.

The debugger is now also aware that your current thread is being blocked by another suspended thread, and suggests resumeing it.

Sources mismatch detection

It might be very annoying and counterproductive if you're stepping over your code unaware that it does't actually match the running code. To avoid any unnecessary time waste, the IDE now immediately warns you once it sees a mismatch.

Debugging without debug info

When you debug code compiled without debug info, you are provided with better name matching, and allowed to set and evaluate values for slot variables.

Version control


Two new actions are available via the Branches popup: Checkout with Rebase and Rename.

The Checkout Tag or Revision action is now applied to all repositories configured for the project.

If you do an Interactive Rebase, IntelliJ IDEA now automatically stashes and unstashes local changes and assists with resolving conflicts.

Git 2.5 introduced worktrees to simplify working with clones of a single repository: instead of making a repository clone you can create a lightweight worktree. Now IntelliJ IDEA lets you work with those worktrees just like you do with regular repositories.

By-word changes highlighting

Merging and comparing revisions with Git and other VCS just got easier with the added by-word difference highlighting.

Now you can also disable inspections in the Diff Viewer to minimize distraction.

Compare revisions between branches

For Mercurial we've made it possible to compare revisions of a file between branches (previously possible only within a single branch).

Move element right and left

Sometimes it might be useful to move statements to the left or right, for example when you're reordering the attributes of an XML element, method parameters, or elements in an array initializer.

To help you do it quicker, we’ve added two new actions: Alt + Ctrl + Shift + Left or Right, respectively (Alt + Cmd + Shift + Left/Right for macOS).

Importing static members

Previously IntelliJ IDEA provided a quick-fix to import static methods. Now it suggests adding static imports in the very same way as it does with regular ones. Static constants are suggested, too.

If you enable Add unambiguous imports on the fly, IntelliJ IDEA will import unambiguous static members on the fly.

Right-to-left languages

IntelliJ IDEA adds support for right-to-left languages (Arabic, Hebrew) to the editor.

Prepend comments with a space

The code styles now provide an option to always prepend automatically added comments with a space.


Method references and lambda expressions

The Inline and Change signature refactorings have been updated to correctly process method references.

The IDE will warn you if you call a method of a functional interface which is directly invoked on the definition of a lambda, method reference or anonymous class. The inspection provides a quick-fix to replace it with the body of the functional interface implementation.

Also, the IDE will report method references which point to a method of their own functional interface type and hence can be replaced with their qualifiers.

Overloaded methods or constructors with similar functional interface type parameters, for which any call sites will need a cast or parameter type specified on the lambda expression to resolve ambiguity, may now be reported as well.

Misuse of java.util.Optional

The IDE will help you avoid writing unsafe code when using java.util.Optional: it will warn you if you call get() without first calling isPresent() to check if the value is available.

Also, the IDE may warn you if you use java.util.Optional<T>, java.util.OptionalDouble, java.util.OptionalInt, java.util.OptionalLong or com.google.common.base.Optional as the type for a field or a parameter, or if you use java.util.Optional or com.google.common.base.Optional types with an array or collection type parameter. Note that this setting is disabled by default.

Migrating Guava code to Java 8

For those who would like to migrate their Guava code to Java 8 APIs, we’ve added a number of quick-fixes that help to replace FluentIterable, Function, Optional, and Predicate with Java 8 analogues.

Concurrency annotations

The built-in inspections that detect issues with use of concurrency annotations now support javax.annotation.concurrent.* (previously reported only for net.jcip.annotations.*).

Declaration access can be weaker

The new inspection called Declaration access can be weaker prevents making fields, methods and classes public unnecessarily. Enable it on the scopes you need.

Ignoring duplicates in generated code

The inspection that finds duplicated code now provides an option to ignore the sources marked as generated.

Speed search

Show usages

We have improved the speed-search in the Show usages popup. Now, when you use it, the matches are highlighted for easier navigation.


Now you can enjoy the speed search even in the Terminal tool window.


Custom source sets

The IntelliJ IDEA project model is finally aligned with that of Gradle and supports custom source sets, by resolving dependencies between individual source sets. This improvement fixes a great number of issues.

Importing EAR artifacts

IntelliJ IDEA now can resolve EAR artifacts defined in your build scripts and configures them automatically in Project Structure.

Spring Frameworks

Spring Boot

The IDE now helps you find usages of your custom configuration properties in your application configuration files and additional metadata files.

Enjoy coding assistance in YAML configuration and banner.txt files.

@SpringApplicationConfiguration is respected in test context setups.

For more details, see the blog post.

Spring MVC

Finally, we’ve added support for @EnableWebMvc-based as and improved working with Java-config only setups.

Spring Core

  • The aliases defined with @AliasFor for @Bean, @Import and @ContextConfiguration are fully supported.
  • Added support for @EnableBatchProcessing, @EnableLoadTimeWeaving and @EnableSpringDataWebSupport annotation.
  • Non-annotated beans that extend CrudRepository now are resolved correctly.
  • Support for Spring 4.3: @Autowired is not required if the bean only defines one constructor.
  • The facet configuration now processes dependencies recursively.
  • A lot of auto-wiring issues have been fixed, as well as the performance has been greatly improved.


The built-in coding assistance has been updated to support Thymeleaf 3, the new version of the popular template engine.

Many issues related to Thymeleaf 2 have been also fixed.

With Thymeleaf users may create their own dialects or extending the standard one. IntelliJ IDEA now understands user-defined dialects and offers coding assistance for them.


IntelliJ IDEA ships with the new features added in Android Studio 1.5.

  • The memory profiler can now assist you in detecting the causes of leaked activities.
  • Several new lint checks.


After a long and exciting road, Kotlin has finally reached the first big 1.0. Welcome the first-class programming language for JVM and Android in IntelliJ IDEA.


Code completion for Scala has been significantly improved. For case classes in pattern matching the IDE now suggests parameter names based on the corresponding field names and their types.

The order of suggestions now depends on the type of symbol and its usage history. The IDE prioritizes local variables, then parameters, then fields, then methods, etc. If the IDE expects a type, it will take that also into account.


ECMAScript 6 and TypeScript

The new refactorings include Create method, Extract method, Inline method and Introduce field.

The new intentions include Make class abstract, Make public/private and Remove modifier.

Any unused import statement is now highlighted. To remove all unused statements, call Optimize imports. Required import statements are added as you type.

Support for TypeScript has been updated to v1.8.

AngularJS 2

Code insight and navigation are available for directives, variables defined in templates, custom event handlers, paths in templateUrl and styleUrls fields, and many other situations.

Enjoy coding assistance for event and property bindings, which also works inside any data binding.

Also, the IDE now understands components defined using the new AngularJS 1.5 module.component() helper method.


The JavaScript debugger for Chrome now makes lots of new things possible. Debug asynchronous client-side code and arrow functions in ECMAScript 6, and stop on the breakpoints set in Web workers.

Also, the IDE now allows you to debug an app’s main process in a built or packaged Electron application, by using Node.js run/debug configuration. You can also debug render process by using Chromium remote debug configuration.

JSON Schema

Thanks to support for JSON Schema, a format for describing JSON files, IntelliJ IDEA can now provide coding assistance for certain types of JSON files. You can add one of the schemas available in the project’s repository, or create your own schema and then map it to a specific JSON file in your project. Code completion for tsconfig.json, .eslintrc and .babelrc is now powered by JSON Schema.

Database Tools


IntelliJ IDEA provides coding assistance the features added in PostgreSQL 9.5.

We've also added support for the PostgreSQL hstore ‘?’ operator.

Table and column comments

Table and column comments now can be added and modified from the Create/Modify Table dialog (if the database supports that).

SQL Server

Custom types in SQL Server (alias types and table types) are now introspected and available for completion.

Table truncation

Sometimes you may want to remove all rows from selected tables. Our new action is at your help.


The Docker plugin has been improved in many ways:

  • We’ve added support for Docker Machine
  • The IDE now offers a separate tool window for Docker.
  • The right-side panel now allows you to see logs and manage environment variables and port bindings.
  • The lists of containers and images are now separate and more readable.

your edition


For web and enterprise development


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