IntelliJ IDEA Ultimate now supports a Beta version of our Remote Development workflow. It allows you to connect to a remote machine running IntelliJ IDEA’s backend from anywhere in the world. All the processing happens on that powerful remote machine, and you can work on your project as seamlessly as if it were on your local one. This functionality can be initiated from IntelliJ IDEA’s Welcome screen or from a new application called JetBrains Gateway, which is available in the JetBrains Toolbox App.
What’s more, you can create, prebuild, share, reproduce, hibernate, and manage dev environments with Space – a unified platform for the entire software development pipeline.
Check out this blog post for more details.
IntelliJ IDEA 2021.3 brings a new, faster way to diagnose and fix issues that are causing your IDE to not work properly. If your IDE isn’t working properly, invoke the new Repair IDE... action from the File menu. It will guide you through a sequence of steps to troubleshoot some of the most common problems.
We’ve added the new Constant conditions inspection, which helps IntelliJ IDEA report non-trivial conditions and values that are statically known to be always true, false, null, or zero. It works the same way as the similar inspection for Java, and it supports most of the same checks. This new inspection can be found in Preferences/ Settings | Editor | Inspections | Kotlin | Probable bugs.
When you want to debug an expression with chained method calls and lambdas, the Step Into action gives you the functionality of Smart Step Into by default. It highlights the methods and lambdas you can step into. To use it, click the Step Into button located in the top pane of the Debug tool window or use the F7 shortcut. The IDE will then highlight the places where you can step into the code, and you’ll be able to select the line you want by clicking on it.
The debugger can now detect Kotlin inline functions and display inline function calls in the stack trace panel. You can navigate to these calls, and you can also inspect and evaluate the variables of each frame.
As requested, we’ve made it possible to change the font size in all open tabs simultaneously with ⌘+mouse wheel on macOS or Ctrl+mouse wheel on Windows and Linux. To enable this feature, go to Preferences/ Settings | Editor | General, choose Change font size with Command + mouse wheel in, and select All editors. If you select Active editor, the shortcut will change the font size only in the file where you are currently working.
IntelliJ IDEA has a helpful option that allows you to preview the results of intention actions and quick-fixes before applying them to your code. This feature is available in the Intention actions menu. To activate the preview, press F1 on macOS or Ctrl+Q on Windows and Linux.
Since its introduction in v2020.1, we’ve continued working to improve the intention preview. In IntelliJ IDEA 2021.3, it works for more intention actions and quick-fixes in Kotlin, and the “Preview isn't available” message has been replaced with more informative HTML descriptions of the intention actions that aren’t supported. What’s more, for an action that modifies several files, the preview displays part of a possible outcome. This partial outcome should be enough to give you a general idea of what the action will change.
In IntelliJ IDEA 2021.3, tables can be created with ease. Simply invoke the context menu and select Insert | Table. That’s it! You can select the preferred size using the mouse hover action or the keyboard.
The cell width in the table will be adjusted as you type. You can edit the table content using the floating toolbars.
To create a new row, you can use Shift+Enter, and Tab to navigate to the next cell.
Working with editor tabs just got easier. Just click the three dots in the right-hand corner of the tab pane to access all the tab actions.
We’ve introduced the new Bookmarks tool window that is destined to replace a similar instance – Favorites. So from now on, you can simply use the F3 shortcut on macOS or F11 on Windows and Linux to mark your files, folders, and classes as important.
When you add a bookmark, by default IntelliJ IDEA puts it in the node named after your project in the Bookmarks tool window. Every time you add a new bookmark, it will appear at the top of the list inside this node. You can sort your bookmarks by type using the Sort Groups and Bookmarks option in the tool window’s settings. You can also create new nodes and drag and drop items in them.
In v2021.3 we’ve made it possible to split the Run tool window with tabs. This allows you to run several configurations simultaneously and see all of the results.
To split the window, drag the tab you want to see to the highlighted area inside the Run tool window and drop it there. To unsplit the window again, right-click the top pane and select Unsplit from the context menu.
When searching for actions, Search Everywhere in IntelliJ IDEA is now powered by machine learning by default. We’ve trained an ML-based formula that takes into account:
We hope you find that the ML-based models boost your search quality and return results tailored to your specific needs.
When you search for usages of a method implementation via ⌥F7 on macOS or Alt+F7 on Windows and Linux, the IDE no longer asks whether you want to find usages of the base method in a pop-up. Instead, IntelliJ IDEA will use top-level hierarchy methods as targets for your search by default. If you want to change this behavior, deselect the Search for base method usages checkbox in the Find Usages tool window settings, which you can access by clicking the gear icon.
The Show Usages dialog has received several useful new features. We’ve introduced the source code preview per found usage, which you can see by clicking the square icon in the top toolbar pane. Another update lets you change the scope of your search with the new drop-down list located next to the Preview icon. What’s more, the window’s title bar now shows the type of code element you are searching for and the number of usages found.
Another minor yet very convenient update allows you to set the dialog width, which the IDE will retain the next time you invoke it.
In v2021.3, you will notice some changes to the nodes in the IntelliJ IDEA Project Wizard.
You can now select the Empty Project node to create a basic project for working with separate files of different types and adding Java and Kotlin classes. The IDE will automatically configure the project so that you can compile it if any Java or Kotlin classes are present.
The new Multi-Module Project node lets you create a project with a complex structure from scratch. Once the project is created, the Project Structure dialog will open, and you’ll be able to add various modules.
IntelliJ IDEA 2021.3 addresses some accessibility issues to make working with the screen reader more comfortable. In response to your requests, we’ve disabled the tool window widget pop-up and the quick documentation pop-up that used to appear on mouse hover. We’ve also fixed an issue with calling the Go to Declaration dialog.
In this release, the accessibility support on macOS has also been improved. We’ve resolved several issues with the voiceover focus and made it possible for screen readers to detect the list items in the New Project wizard when you create projects. To minimize distractions while you're coding, we've decreased the number of help tooltips that play sounds.
IntelliJ IDEA now warns you about hazards such as SQL injection and XSS flaws, sensitive data leaks, and insecure deserialization. It also prevents you from passing insecure data to secure methods. These additional warnings are provided by our new Non-safe string is passed to a safe method inspection.
For this inspection to work, you need to annotate strings as
( “safe”) or
@Tainted (“unsafe”). These annotations will become valid
when you add the
We’ve added two inspections that can help you to simplify your code. The first
one suggests that you replace
You can use it with Java versions 16 and up. Another inspection prompts you to replace
map.putAll(Map.of("a", "b")) with
When you introduce a local variable in Java, the settings that are applicable to it no longer appear in a pop-up, which used to cover the code you were writing. Instead, you can access these options by clicking the gear icon next to a variable or by using the ⌥⇧O shortcut on macOS or Alt+Shift+O on Windows.
We’ve also improved the Introduce parameter refactoring. When you invoke this refactoring, with ⌥⌘P on macOS or Ctrl+Alt+P on Windows and Linux, the IDE asks where you want to replace occurrences. After you make this selection, a gear icon will appear, and clicking on it will allow you to configure more settings for the refactoring.
Sometimes you may need to define custom classpaths in the Run/Debug Configurations dialog on a per-config basis. Starting from this version, it is possible to do so by selecting Modify options | Modify classpath.
We’ve introduced a new refactoring that lets you extract constants in Kotlin. To use it, put the caret on a string and press ⌥⌘C on macOS or Ctrl+Alt+C on Windows and Linux.
The Possibly blocking call in non-blocking context inspection warns you if you use a coroutine in the wrong context. In this release, the inspection works not only as a warning but also as a context-dependent quick-fix.
What’s more, we’ve made some further improvements. This inspection now covers more cases, and you can customize it, so it works better in your particular environment.
Sometimes it can be difficult to understand the various ways to declare the ranges that Kotlin supports. To make it a little easier, we’ve added inline hints that explain with plain mathematical signs what the words or symbols in the ranges mean. If you don’t need this feature, you can easily disable it by right-clicking on a hint and selecting Disable ‘Ranges’ hints type.
We’ve reworked the layout of the New Project wizard by adding tooltips for all of the fields, so you can easily understand what info they require. The templates section has received an update as well – we've removed some of the unpopular templates and added a new one that lets you create a Compose Web Application.
And finally, the project set up step has become much simpler. You now only need to fill in the basic fields.
The main focus of this release has been Scala 3 support. We've added highlighting,
navigation, and autocomplete for
end markers. There's now autocomplete
export keywords, soft
keywords, and the quiet syntax. The TASTy reader can now parse
package object, as well as variance and bounds in higher-kinded types.
The highlighting of lexer and parser errors is now significantly faster. There are
more inspections that are compatible with Scala 3. We've improved the resolve of
given imports and supported
final top-level members and
abstract lazy val.
Many projects that should be compiled for both Scala 2 and Scala 3 are modeled as Scala 3 projects cross-compiled for Scala 2, even though technically they are Scala 2 projects.
Opening such projects as Scala 2 allows the IDE to use the correct Scala version, and is more reliable.
The Scala plugin now supports data flow analysis, which can help you detect programming errors more easily. You can read our recent blog post for more details.
There are tons of different options in the Scala compiler, and very few programmers learn them by heart. Furthermore, those options vary depending on the Scala version in use.
You can now autocomplete the applicable options and even see Quick Documentation for each of them.
Have you ever wondered whether
1 to 3 is an inclusive or exclusive range?
And what about
1 until 3? Or
Range(1, 3)? Set your doubts
aside – now the answer is clear.
IntelliJ IDEA 2021.3 allows you to update your npm packages to the latest version right from the editor! Open your package.json file, place the caret on the package version you want to update, and then press ⌥⏎ on macOS or Alt+Enter on Windows and Linux and select Update ‘package name’ to the latest version. A quick-fix will also be shown when you hover over the package version.
We’ve improved the way code completion works in HTML. Whenever you type a tag name or an abbreviation in the editor, or invoke code completion, IntelliJ IDEA will show you relevant suggestions right away. Previously, it would only show them if you typed < first. Additionally, code completion for character entity references should now work better.
This highly-anticipated new feature allows you to specify an HTTP or SOCKS proxy server for your SSH configuration in Preferences/Settings | Tools | SSH Configurations. Under the new HTTP/SOCKS section, you can select the proxy type, enter a hostname and a port, and apply authentication with a username and password, if necessary. It is also possible to sync your SSH proxy settings with the global IDE ones. To do so, select the Use global IDE proxy settings checkbox.
It is now easy to check whether the changes you’ve made worked for your program or caused a regression. To do so, just open two snapshots that you want to compare in the Profiler tool window. In the most recent snapshot, click the diff icon and select the snapshot you’ll use as the baseline. The IDE will display the result in the form of a flame graph, call tree, or method list.
In v2021.2, we added support for Async Profiler 2.0 to the macOS and Linux versions of IntelliJ IDEA. Starting from v2021.3, the Windows version supports Async Profiler 2.0 out of the box as well. This support provides a smoother profiling experience and also improves the way native functions are displayed in snapshots.
This release takes some steps toward improving our Run/Debug configurations, and this time, Maven configurations have received a significant redesign. The key parameters are all grouped on one screen, while additional options are available via Modify options.
If you want to configure the Maven settings for each project in the .mvn/maven.config file, go to Preferences/ Settings | Build, Execution, Deployment | Maven and select Use settings from .mvn/maven.config at the bottom of the screen. Please keep in mind that the settings from this file override the standard Maven UI settings.
When you need to check out the selected branch and rebase it on top of a branch that is currently checked out, you use the Checkout and Rebase onto Current action, which was previously available for local branches only. In IntelliJ IDEA 2021.3, you can use it for remote branches as well.
We’ve improved the way the settings in Preferences/Settings | Version Control are structured, and we’ve made some of the critical configurations there more discoverable. The Version Control node now serves as the starting point for navigation, with links to all the available settings. If you go to the Git node from there, you’ll notice that we have divided all the settings into sections that account for the most important processes: Commit, Push, and Update. Additionally, the parameters inside these sections are now organized more logically. What’s more, we’ve added a separate node for Directory mappings, and the background operations are now switched on by default. The Background node no longer exists.
Starting from IntelliJ IDEA 2021.3, your IDE shows the difference between commits in a separate Changes tool window located to the left of the editor.
We have a new action that allows you to push only the commits you are confident about and leave the rest for later.
It allows you to push commits up to the one you have selected in the Log tab of the Git tool window. To use it, pick the commit you want to stop at, right-click on it to call the context menu, and select the new Push All up to Here action.
We’ve added the new Align Changes Highlighting option to the Diff screen settings that can be found under the gear icon. This feature makes the Diff easier to read, especially when there are complex modifications, because it aligns the unchanged lines so that they are displayed next to each other. This helps you see the code that has been added or removed more clearly.
Our newly added typeahead support in the IntelliJ IDEA terminal predicts text modifications and instantly displays them in light grey. This feature allows you to type in the terminal equally fast on both a local or remote machine.
In this release, we’ve improved the discoverability of the Evaluate feature. Previously, when users needed to evaluate something, many of them resorted to using watches. They just created a watch and then removed it, instead of using the Evaluate dialog. The Evaluate field is now accessible right in the Debug tool window, making the most convenient way to evaluate expressions more obvious.
IntelliJ IDEA’s HTTP client provides basic support for gRPC requests. When you type the GRPC keyword to start your request, the HTTP client offers code completion. Thus, your IDE prompts you about all known gRPC services, unary and server-streaming methods of a particular server, and, most importantly, fields of the request body.
Another new feature allows you to generate a gRPC request in the HTTP client. To do
so, just click on the gutter icons in your
The HTTP client can detect images in responses and display previews of them in the response console.
When testing streaming applications in IntelliJ IDEA, you no longer need to wait for a stream to end because the HTTP client will display the output on the fly. This is now possible because we’ve added support for the following content types: text/event-stream, application/stream+JSON, and application/x-ndjson. You will also be notified when a stream ends.
In the HTTP client, it is possible to redirect output to a custom file or directory. You can use two operators for forced and soft redirects:
>> operator always creates a new file, adding an -n suffix
to the file name if the requested file name already exists.
>>! operator rewrites the file if it already exists.
You can add request identifiers either as comments via @name or as text in the first separator (###). The IDE understands these identifiers and allows you to invoke requests by them from the Services tool window, as well as from the Run Configuration, Run Anything, and Search Everywhere dialogs.
Qute is now among the supported template languages. This means that IntelliJ IDEA provides code highlighting, autocompletion, and other useful features to help you develop templates for your Quarkus project.
IntelliJ IDEA can detect when your OpenAPI specifications are located in several
files and linked via
$ref, and it will provide completion.
We’ve made 2 additions to the JetBrains
annotation collection. Once you add
'org.jetbrains:annotations:23.0.0' to your project dependencies, you can annotate
your classes and methods as
This will make it possible for the IDE to detect blocking calls in non-blocking
contexts, such as Kotlin coroutines or reactive code with Project Reactor, RxJava,
and SmallRye Mutiny.
What’s more, the IDE automatically supports the corresponding annotations from Micronaut and SmallRye Mutiny.
IntelliJ IDEA now detects more cases of blocking code in Spring and Java EE,
including Spring Data’s JpaRepository and CrudRepository, RestTemplate and
JdbcTemplate, Spring Feign interface methods, JPA EntityManager calls, and
any methods and classes annotated as
We’ve reworked the Run/Debug Configurations dialog for Spring Boot projects. The design is similar to previously updated configurations for Java. The new interface presents the key settings on one screen and allows you to configure more parameters via Modify Options.
IntelliJ IDEA now provides code completion in additional configuration files
.yaml files) when a spring.config.import key is used
to reference another file. It is also better at setting up complex and custom Spring
Boot configuration files.
For Spring Boot projects, the IDE now supports code completion and find usages for
references to application.yaml from
@NamedQuery used from Spring Data repositories
Query method completion now works for queries declared as
in Spring Data JPA projects. You can also navigate to the definition of a
@NamedQuery via the gutter icon.
Starting from v2021.3, you can use all CDI inspections in Kotlin files. Previously these inspections only worked in Java files. Additionally, we’ve added CDI gutter icons in Kotlin files. They allow you to navigate easily to injection points or injection candidates, bean makers, disposer methods, and events.
We’ve sped up all the processes for UML class diagrams, both in Java and Kotlin. Diagram opening, switching between categories, zoom, and the undo/redo functionality now all take much less time. Other notable changes include a new grid, member highlighting, and a quick documentation preview pop-up.
If you need to control the appearance of the diagram, use the context menu and select Appearance.
We’ve added the ability to display an Aggregate view for a range of cells. This is a long-awaited feature that will help you manage your data and spare you from having to write additional queries! This makes the data editor more powerful and easier to use, bringing it a step closer to Excel and Google Spreadsheets.
Select the cell range you want to see the view for, then right-click and select Show Aggregate View.
This release is a logical continuation of the previous one, which introduced the ability to generate a DDL data source based on a real one. Now, this workflow is fully supported. You can:
Just as a reminder, a DDL data source is a virtual data source whose schema is based on a set of SQL scripts. Storing these files in the Version Control System is a way to keep your database under the VCS.
There is a new tab in the data configuration properties, DDL mappings, where you can define which real data source is mapped to each DDL data source.
The new Database Diff window is available from the context menu. It has a better UI and clearly shows in the right-hand pane what result you’ll get after you perform the synchronization.
The legend in the right-hand pane shows what the colors mean for your potential result:
The Script preview tab shows the result script, which can be either opened in the new console or run from this dialog. The result of this script is applying changes to make the database on the right (target) a copy of the database on the left (source).
Besides the Script preview tab, there are two more tabs on the bottom pane: Object Properties Diff and DDL Diff. They display the difference between the particular versions of the object in the origin and in the target databases.
We’ve introduced three levels of introspection for Oracle databases:
Introspection is fastest on level 1 and slowest on level 3. Use the context menu to switch the introspection level as appropriate.
The introspection level can be set either for a schema or for the whole database. Schemas inherit their introspection level from the database, but it also can be set independently.
The introspection level is represented by the pill-looking icons located next to the data source icon. The more the pill is filled, the higher the level. A blue icon means that the introspection level is set directly, while a grey one means that it is inherited.
A huge update brought support for UI test automation in Selenium – the visual editor can now help you to maintain existing page object classes. Previously, it was only possible to generate new page object classes, but now you are even able to update the existing page object classes directly without a visual editor. IntelliJ IDEA will detect page object classes automatically and indicate them with a corresponding icon on the gutter panel. By clicking on that gutter panel, the user can open a visual editor and grab new elements to be added to the page object class.
The newest plugin from the Test Automation Kit got a few minor bug fixes, but also a useful feature in multiple data generator settings. Now you can modify the prefix, suffix, and delimiter with a multiline definition.
We implemented support for multilevel test runs. You can now create multiple child test runs for specific functionality domains or types of testing. Each parent test run aggregates the results of the child test runs and provides summary statistics from all sub-related test runs.
If you choose to manage test cases in Markdown files using our “Local TMS” feature, you will be able to easily declare test steps and share them among multiple test cases. Shared steps are declared as a regular Test Case with a unique numeric ID. You can refer to that test case in other test cases and IntelliJ IDEA will substitute those referenced test case steps when generating previews, test runs, or code templates for an automatic test.
You can format your Helm templates and be sure of the correct result. We’ve fixed all the related issues, and the formatting is now much more reliable. To see the improvement, go to Code | Reformat code or Reformat file or press ⌥⌘L on macOS or Ctrl+Alt+L on Windows and Linux.
We’ve added highlighting of such block elements as
define in Helm templates.
This makes it a lot easier to work with code that contains Go templates inclusions.
IntelliJ IDEA now supports automatic code injections of various languages in ConfigMap
resources for keys with extensions like
.properties, and so on. The injected pieces of code are highlighted
in green, and it is possible to use our code insight functionality inside them,
including code completion, error highlighting, and others.
It is now possible to rerun your latest helm command from the Services tool window. All you have to do is click the new icon in the top right-hand corner. For example, you run the helm lint command, and after it completes, you can click the icon to repeat it.
It is now easy to connect to a Docker daemon from Minikube. In Preferences/ Settings | Build, Execution, Deployment, select the Minikube radio button. In the field next to it, the IDE will automatically display the detected Minikube's docker-daemon environments that you can use for connecting.
Connecting to Docker has become faster because you can simply double-click on the necessary node or use the new shortcut – ⌘Enter on macOS or Ctrl+Enter on Windows and Linux. The Start container action can also be invoked with this shortcut.
The new Clean up action works just like the prune terminal command. When you right-click on the Networks, Volumes, Containers, or Images node, you can select Clean up, and the IDE will delete the unused objects. You can also apply this action to the Docker root node to prune all the unnecessary objects in one click.
IntelliJ IDEA supports Compose V2, which allows you to run Docker Compose commands as docker compose, instead of docker-compose (with a dash).
To activate this option, go to Preferences/Settings | Build, Execution, Deployment | Docker | Tools and tick the Use Compose V2 checkbox.
Image layers allow you to track all the commands that are applied to images. To access them, select an image and go to the Layers tab. From there, when you choose a command, you can click on the Analyze image for more information link on the right-hand side of the screen for more detailed info about the changes applied to each layer.
If you have a preconfigured container that you want to use later, you can save it as an image locally and push it to continue using it remotely when you need it. Go to the Services tool window, right-click on the container, and select Image | Save as a new Image.
We’ve added several changes to the Docker registry. First off, the IDE now displays all available registries in separate nodes in the Services tool window. Previously we only had support for the Docker Hub registry. In v2021.3, we’ve added support for GitLab (registry.gitlab.com) and JetBrains Space (<username>.registry.jetbrains.space).
You can expand the registry nodes in the Services tool window, select the necessary image, and pull it to the desired location. If you have several Docker connections, the IDE will ask you where to pull the image. It is possible to push images to any added registry, and in the Push dialog the IDE automatically detects the available namespaces in the given registry and lets you select one from the drop-down list.
Last but not least, you can use image completion for images from the JetBrains Space, GitLab, and Docker Hub registries.
Once Podman has been installed and configured on your OS, you can connect to it via Preferences/Settings | Build, Execution, Deployment | Docker by selecting the TCP socket radio button and filling in the required fields.
You can now create merge requests and code reviews for your projects in Space. You have 2 different options:
+ icon on the top toolbar of the Code Reviews tool
window and select the desired action.
For more details, check out this blog post or refer to the gifs below.
All the files that you haven’t yet revised when performing a code review will remain marked with blue dots until you open them. This way, you won’t miss any critical changes. If you want to return to the changes later, you can select Mark as Not Viewed from the context menu. This feature also works for GitHub pull requests.