IntelliJ-based IDE Features Roadmap for 2020

This is the second part of the roadmap of IntelliJ IDEA and IntelliJ-based IDEs for 2020. The first part of the roadmap was focused mostly on low-level features in the platform. In this post we’ll be talking about higher-level features, ones that the users will directly interact with. Some of these features will roll out in 2020.1, and others will appear in releases later during the year.


Last year, we localized the JetBrains Website and made it available in 8 different languages. Now we’re happy to announce that we’re working on localizing IntelliJ-based IDEs. We’re working on IDE localization for the Asian markets and planning to provide initial support in Chinese Simplified. Korean and Japanese are next on the list. It will be possible to install translations as plugins, so the community will be able to provide translations for other languages.

image (12)

Using the IDE as a General-purpose Editor

A long-standing user request is for the ability to use our IDEs as general-purpose text editing tools, for viewing logs, editing configuration files, and other non-code-editing use cases. To some degree, this is already supported – for example, you can open files from the command line. However, opening a file outside of a directory containing an IntelliJ project (the .idea directory) always created a temporary project, which cluttered your disk with useless project files and caused other inconveniences.

With the recent startup performance improvements, the possibility of using our IDEs as lightweight text editors has become more plausible, so we’re now building a dedicated mode for editing non-project files. In this mode, the IDE will work more like a simple text editor. It will open even faster, it won’t store any project configuration, and it will use the same workflow as a regular text editor for creating, opening, and saving files.

The set of features available in this mode will also be very limited. However, you’ll be able to easily switch to the full project mode if you need to use features such as refactoring or debugging.

Git Staging Support

Support for the Git staging area is the most voted for feature request for our Git integration. Historically, the Git integration in IntelliJ Platform has been built on top of the same framework as other version control integrations (such as Subversion and Perforce), and instead of the staging area, it supports the concept of changelists. Changelists are more flexible than the staging area because they allow you to manage multiple sets of independent changes that you aren’t ready to commit. With the recently added support for moving parts of a file between changelists, we’ve basically covered the main use cases of the staging area.

However, support for changelists in Git is specific to the IntelliJ Platform. The command line Git and all other clients, support the staging area instead. People new to our IDEs don’t always understand how to work with changelists or how to use them to handle the scenarios that they currently use the staging area for.

Because of this, we plan to implement two different modes for the Git integration in future IDE versions. You’ll be able to choose whether to use the current UI, based on changelists, or a new UI that supports the staging area but does not support changelists. (Combining the two doesn’t seem to be feasible because the combined UI would be far too complex conceptually.)

Machine Learning-based Completion

We’ve been exploring the use of machine learning for improving code completion for quite some time already, and the results of some of this work are already in production. Current versions of IntelliJ IDEA use machine learning to improve the ranking of completion variants. Language plugins tag each produced completion variant with various attributes, and ML is used to determine which attributes should contribute to item ranking so that most relevant items are shown at the top of the list.

This year, we’re going to roll out additional ML-based completion features. We’re teaching ML completion to make better use of the context for ranking completion suggestions and to generate completion variants that go beyond a single identifier (full-line completion). Of course, it’s essential for us to ensure that the variants we suggest always make sense, so it may take a while before full-line completion appears in the product. But in any case, this is a major area where we are investing our efforts.

Onboarding and Environment Setup

One additional area of focus is to make it easier to get from a clean machine to a fully working development environment. Once the user has installed the IDE, it will be able to take care of installing everything else required to develop and run the user’s projects – Git, the JDK, and so on. We’re also simplifying the initial configuration of the IDE and the workflow for importing or creating a project.

This work matters not only for novice developers, but also for people new to a specific set of technologies – even if you have many years of experience with a language, getting familiar with a completely different language and environment can sometimes be quite baffling. We want to ensure that our IDEs can assist you on your journey and help you become productive as quickly as possible.

Refactoring Autodetection

For us, the support of automated refactorings has always been one of the strongest elements of our IDEs. However, our usage statistics show that a significant percentage of our users do not use them. Rename is used fairly broadly, but more advanced refactorings such as Extract Method and Change Signature are not among the 50 most commonly invoked actions. To unlock the value of the IDEs for our users, we’re putting a lot of effort into making refactorings more discoverable.

For example, we’re adding the possibility to detect changes in the declaration of a method and adjust its usages accordingly. If you rename a method, or add, remove, or reorder its parameters, IntelliJ IDEA will show a tip that will make the corresponding changes to its calls. This gives you the benefit of our rich refactorings without requiring you to learn how to invoke the refactoring explicitly.

Code Vision

Some time ago Rider, our .NET IDE, introduced support for Code Vision: displaying rich contextual information directly in the code editor. We plan to extend this support to IntelliJ IDEA, so that you’ll be able to see this information, such as the author of each method and the number of its usages, directly in the editor. The annotations are interactive. For example, clicking on the number of usages will allow you to navigate to the list of usages.


All of this is subject to change, and it’s quite possible that some of the work described above will not be released, in which case we’ll have other awesome stuff for you, instead.
Feel free to leave your feedback in the comments below. And please stay tuned for Early Access Program announcements, which will let you know when some of this work is ready for you to try.
Happy Developing!

This entry was posted in New Features and tagged , . Bookmark the permalink.

61 Responses to IntelliJ-based IDE Features Roadmap for 2020

  1. ADEV says:

    Few months ago there was mention of plugin API that doesn’t require reload IDE, is there progress on this?

    I am very interested in this, i avoided writing plugins for IntelliJ because it felt way to “bloated”, it requires specific/separate intelliJ installation and require reload all the time, it was slow workflow

    So having API that doesn’t require reload entire IDE will be a great +

  2. Pavel Zlámal says:

    I’m glad, that you plan to extend localization support. I translated some UI elements to Czech, but eventually stopped, since its really hard to integrate it (its not plugin) and with each new version it means to checkout new files a manually check changes.

    I hope there will be some UI or actions to quickly point out new/changed strings between IDEA versions, so the translation process is smooth -> focused on translation itself.

    Also it would be nice, if translation could be loaded dynamically or at least simply set in settings and kept between restarts. I already provide translation in my plugin, but it looks weird in IDE, where the rest of the UI is in English. So loading preferred language, instead of system locale is better in this case.

  3. Vladimír Říha says:

    How about a support for projects located in WSL? Aka opening WSL projects in IDE, running them etc?

  4. inkompotato says:

    Will we get Touchscreen support in 2020?

  5. Dominik says:

    For some time you were working on a deeper integration of GitHub code reviews (comments and full reviews from within the IDE). Is there any progress or is it at least still on the roadmap?

  6. Chinese user says:

    There are many crack program for jetbrains IDE in China.
    Why you guys still willing to add Chinese support?

    —-from A Chinese user

    • Dmitry Jemerov says:

      Because we see many Chinese companies willing to buy licenses to JetBrains IDEs, and in China the use of English in the UI is a bigger barrier to adoption than in many other countries.

    • LinWanCheng says:

      Our company has not purchased yet. I’m using the community version. Httpclient, connecting to MySQL, and tomcat are the functions that I would like the community version to have. Others are okay. I hope idea supports Chinese sales and recommend them to ICBC. The employees hope to use the ultimate Version.

  7. Charlie Hayes says:

    Code vision looks cool but I’m worried it will be disorienting having phantom lines in the ‘code’. The similar feature, parameter names, already exists and it’s extremely disorienting moving the cursor and it jumping all around.

    • Russ G says:

      I have turned off parameter hints because it gets in the way while editing. Also when taking a screenshot, people not familiar with that feature thinks it is part of the syntax and then complain that something is wrong with the code.

    • Dmitry Jemerov says:

      Code vision is optional (just as parameter hints are), and we don’t expect all our users to leave it enabled.

      • Cedric says:

        I also have disabled the parameter hints because they are distracting.
        I would however appreciate having the hints and Code Vision being controlled by a command.
        For example, View>Code Vision (Ctrl+Shift+Q).
        Similar to Context Info (Alt+Q), it would disappear when I start coding again but like Quick Doc (Ctrl+Q) would be “sticky” when pressed twice.

        • Dmitry Jemerov says:

          Hiding Code Vision on file modifications is an interesting idea; we’ll consider it. Thanks for the suggestion!

      • Charlie Hayes says:

        Is there a chance this helpful feature can be added in a way that’s less invasive?

        • Dmitry Jemerov says:

          The entire idea of Code Vision is presenting information that’s already available inside the IDE (through features such as Find Usages and Annotate) directly in the code editor. There’s quite a lot of demand for this functionality, and the implementation that we currently have in Rider is the best way known to us of showing this information.

  8. jerryouyang says:

    Looking forward to the code vision feature !

  9. Reece Dunn says:

    With the machine learning for completion variants, is there a way to pass additional context properties to the completion engine (e.g. as a list of string tags). The context for this is three-fold w.r.t. XPath and XQuery functions:
    1. some of the functions have properties like “deterministic”, “context-independent” (use/don’t use the . context item), and “focus-independent”;
    1. various functions are available in specific contexts (e.g. XSLT only), or vendors (MarkLogic, BaseX, Saxon, etc.);
    1. functions may be in different groups (accessors, trigonometric functions, etc.) in the documentation.

    • Dmitry Jemerov says:

      Looks like all of this can be handled without ML support, simply by extending the XPaht/XQuery code completion support in the plugin.

      • Reece Dunn says:

        The last part is difficult to support within the plugin, as there is no easy way to know what the user is doing at that point (aside from filtering based on return type information, which could filter to some extend but not completely).

        I was just wondering if there was a way to provide additional information that a plugin is aware of to the ML framework to make it display better completion results. For example, it could identify that the file is implementing search or a statistical query and showing the related functions above the others.

  10. Stu says:

    I hope the changes speedup changes implement some sort of scheduling between editors.
    Back in my old job, at startup I would open 6 or so big projects all at once in different pycharm instances.

    They would all start indexing at once and bog down the computer even with an SSD.

    It would be great if background tasks could be aware of other IDEs and make some effort not to swamp IO devices.

    • Dmitry Jemerov says:

      Running multiple independent IDE instances at the same time is not an officially supported way of using our IDEs (you can do this but it requires manual configuration), and we currently have no plans to implement communications between IDEs running in this fashion. We expect that indexing improvements described in the previous roadmap post (especially prebuilt index chunks) will provide a better solution for this problem.

  11. Oleksii Ignachuk says:

    What is the state of performance optimizations? Will we see any improvements or, at least, fixes for critical issues (e.g. Kotlin copy-paste, edit)? All these marketing improvements are great for getting more clients, but what about helping existing users? such issues still do not have fix date or release.

    Another question is when IDE will stop using one CPU core for all open windows? Is it supposed for everyone to work with one project only? In 2k20 while having AMD Threadrippers accessible for common desktops?

    • Dmitry Jemerov says:

      Please read the first part of our roadmap for detailed information on the plans of the IntelliJ IDEA team regarding improving performance and moving computations out of the event dispatch thread.

      As for the Kotlin plugin performance optimizations, please contact the Kotlin team. I’m aware that the perfomance problems related to copy/paste in Kotlin have been fixed and will be released soon; I don’t have further information on KT-34434.

  12. graudeejs says:

    Would be cool to have Ruby debugger (in RubyMine) that actually works.

  13. Stephen Friedrich says:

    About git staging support versus changelist you wrote:
    “Combining the two doesn’t seem to be feasible because the combined UI would be far too complex conceptually.”

    I would really like to know why it is so complex *conceptually*:
    As proposed in the youtrack issue, my naive idea would be to have an additional change list called “Staging Area”. Just have all changes there staged automatically and keep changes in all other changelists unstaged.
    Where is my blind spot?

    • Dmitry Jemerov says:

      For example, when you add a file to Git, we stage it (so that it’s not seen as unversioned by command line tools). An added file can be in any changelist.

  14. Kyle Albert says:

    The focus issues that have been around for quite some time (the one where the cursor/caret disappears) still happens. While it’s less frequent than it once used to be but it’s still super annoying. Latest 2019.3.2 with the JetBrains focus plugin.

    Also a big one: the right-click menu selection often gets stuck after a submenu opens when moving past it with the mouse cursor.

    • I have seen both of these myself.

      Bug-fixing and performance-tuning are a bit more important than the machine learning crap which will probably either predict incorrectly more often than not or bring the CPU to 100%, but what can we do.

  15. Yong Liang says:

    When will localization be available

  16. LinWanCheng says:

    I hope that middle-clicking on any string (including the comment) can intelligently open classes, files, and symbols, such as method names written by annotations, class names on Pointcut, and related description files written by comments.

  17. Mike Fahy says:

    Using the IDE as a General-purpose Editor will be a huge step forward! I might even start learning the default JetBrains keyboard shortcuts, instead of changing them to match SublimeText’s.

  18. ABC says:

    Do you think chinese will buy it. xD

    • n太白 says:

      Please don’t generalize, our company did not buy IDEA for us, but we also bought a personal version for ourselves. People who don’t pay do exist, but not everyone. We are willing to pay for a good IDE.

  19. SUMIT SHUKLA says:

    Please make IDE free to use as visual studio code is gaining popularity.

    • Dmitry Jemerov says:

      IntelliJ IDEA has been competing with free products for most of its existence; Eclipse and NetBeans are also free to use (and Eclipse used to be far more popular than our tools). We believe that our tools provide enough value to justify the license price. If for you, personally, they don’t, you’re welcome to use a different IDE or editor.

  20. James R says:

    Still love IDEA after all these years… but the kotlin refactorings are so poor compared to java. The speed also way slower in kotlin projects. Please don’t get distracted with fancy stuff that you forget core features. SSR, inline, make instance method and so many more all missing in kotlin.

  21. Mehrdad says:

    You mentioned use of refactoring utilities in Jetbarins IDEs. As a JavaScript developer I use webstorm daily, compared to IntellijIdea refactoring is much worse. Not only the refactoring but also the amount of assistence Intellij gives me is much more than Webstorm. Webstorm can’t really auto import my components from the installed packes. Is this because of the static type nature of Java that its ide is much better?

  22. Jorgen says:

    General purpose editor support, like Visual Studio Code, Atom, Sublime, etc would be awesome. I always use Intellij for the code I’m working on.

    But I also need to browse a lot of code and search through it. For this I use Sublime which is a really fast and lightweight editor. I open all the code repos in the organization in a single sublime project. This starts up in less than a second with a huge amount of code. It’s really convenient to be able to search, read and analyse the code. When I need to change something move to Intellij. This is really annoying because it’s two different platforms and I have to learn different shortcuts.

    I would love if Intellij would be able to just open a folder with a lot of code, configfiles, text, json, xml, etc in a kind of lightweight way without compilation, building, project-files generation, etc. Just a simple lightweight editor experience like Sublime, Atom, VSCode, etc provides.

    • Just curious – how do you read and analyze a code without an ability to efficiently navigate through it?

    • Have you tried unloading modules? That seems to work well for the most part in my experience, the only issue being that with Gradle projects I have to sync the project in order to re-load the modules after an IDE restart with unloaded modules. However, that is rare enough that it has not been a problem for me.

  23. direnjie says:

    Hello, I would like to ask what the translation plugin said in the article, I did not find

    • Dmitry Jemerov says:

      The article announces our plans for the entire year 2020. Given that now is mid-March, most of the things described in it are not yet available. The translation plugin will be announced once it’s ready.

  24. 陈冲 says:

    I am looking forward to the arrival of Chinese interface support. In the past, netbeans 8.2 has been used mainly for Chinese interface support, which is very good, but idea is more helpful. Unfortunately, without Chinese interface support, it will cause some inconvenience

Leave a Reply

Your email address will not be published. Required fields are marked *