What’s New in IntelliJ IDEA 2023.3

IntelliJ IDEA 2023.3 introduces a new Run to Cursor inlay option that allows you to execute up to a specific line of code while debugging. Once your program is suspended, simply hover over the line of code you want to execute up to and click on the Run to Cursor popup. You can also use this feature by invoking the keyboard shortcut (Alt + F9) after the caret is placed on the desired line.

IntelliJ IDEA 2023.3 introduces a floating toolbar that appears next to selected code fragments and provides easy access to editing actions such as Extract, Surround, Reformat, and Comment, as well as context actions. You can use the kebab menu (three vertical dots) to customize the floating toolbar. To hide it, you can either use the same menu or go to Settings/Preferences | Advanced Settings | Editor and check the Hide floating toolbar for code editing option.

In response to your feedback about the new UI, we’ve implemented an option to hide the main toolbar when using the IDE’s default viewing mode, just like in the old UI. To remove the toolbar, go to View | Appearance and uncheck the Toolbar option.

IntelliJ IDEA 2023.3 further improves the ability to save multiple tool window layouts and switch between them, introduced in v2023.1. The new Default layout option provides a quick way to revert your workspace’s appearance to its default state. This layout is not customizable and can be accessed through Window | Layouts.

Following the release of string templates in Java 21, we’ve implemented a new inspection to streamline the replacement of concatenated strings. The IDE will now provide a quick-fix suggestion to replace concatenation with the STR template processor.

It’s now possible to apply the Move refactoring to local classes, allowing you to relocate them within your codebase. To do this, start by applying the Convert local to inner refactoring, which can be accessed through context actions or by pressing F6. Once the conversion is complete, invoke the Move refactoring by pressing F6 again and select the desired destination for the class.

IntelliJ IDEA’s code analysis now covers more scenarios when identifying and highlighting potential errors in conditional expressions that always evaluate to the same value. For example, the IDE can now recognize possible string lengths or estimate string concatenation outcomes, prompting inspections when redundant or potentially problematic code is detected. Learn more.

For those new to IntelliJ IDEA and Kotlin, there is an option to open a new project containing sample code, which now comes with onboarding tips. In the New Project wizard, check Generate code with onboarding tips to get a basic sandbox project with hints demonstrating some of the IDE’s essential features. Following these tips in the sample project allows you to try out various features, making it easier to familiarize yourself with the IDE.

Now, for the IntelliJ build system, you can create a project that uses a concise project structure with less folder nesting. The path to the Main file appears as src/Main.kt instead of src/main/kotlin/Main.kt. This helps you save time navigating the project and reduces the overall complexity in projects where extensive nesting isn’t needed.

If you add a Kotlin file to a Java module, IntelliJ IDEA can now automatically add all the necessary Kotlin dependencies by changing the build scripts. You can easily review these changes and undo them. Auto-configuration is currently available for Gradle projects that meet specific criteria, explained in this blog post.

In the recent Kotlin 1.9.20 release, we announced the Beta version of the K2 compiler. Projects that use the K2 compiler are now fully supported in the IDE, and the bundled Kotlin IDE plugin treats them the same as K1-based projects.

It is important to note that the bundled Kotlin IDE plugin still uses the K1-compiler under the hood. A K2-based IDE plugin is under development and will be announced in the near future.

As of v2023.3, support for new Kotlin versions comes bundled in IntelliJ IDEA and Android Studio updates, meaning that you no longer need to update the Kotlin plugin from JetBrains Marketplace. With every major IDE release, you can expect built-in support for upcoming Beta and Stable versions of Kotlin.

IntelliJ IDEA 2023.3 introduces a new way to create Kotlin Multiplatform projects – the Kotlin Multiplatform web wizard. The wizard ensures the same user experience on all platforms, and it also means you will get new updates faster as they come out independently of the major IDE releases. We are planning to implement an IDE version and create a command line tool in the future. The new wizard currently covers the most popular Kotlin Multiplatform use cases, and we will continue to add more functionality to it.

Kotlin modules are back! With v2023.3, it is once again possible to add Kotlin modules to your project, meaning that you can create multi-module Kotlin projects with ease. We will continue to improve the reworked functionality.

IntelliJ IDEA 2023.3 offers enhanced Scala 3 support with a particular focus on enums. The IDE now detects and warns about unextendable enums, provides improved propagation of annotations and modifiers to generated symbols, and offers precise type widening of apply methods, considering only direct supers. Errors due to duplicate synthetic elements are now highlighted correctly, and auto-completion for enums has been enhanced. Furthermore, we've improved Scala 3 code analysis, eliminating the invalid error highlighting that occasionally occurred in seemingly random cases. We've also refined code highlighting for inline parameter modifiers, in addition to enhancing the Parameter Info popup.

IntelliJ IDEA has become much better at detecting unreachable code, and many red code false positives have been eliminated. The IDE now accurately identifies code used within the context of thrown exceptions and try, catch, and finally blocks, while also taking into account implicit imports. Additionally, we've introduced the ability to suppress the Unused declaration and Method can be private inspections for non-standard Scala files, like worksheets.

In IntelliJ IDEA 2023.3, we've revamped the workflow for configuring inlay hints for Scala, making it easier to understand the types of inlay hints available and how to utilize them. These hints are now aligned and positioned on the right-hand side of the screen, ensuring they don't obstruct your code.

Inlay hints and other information that appears in the editor is meant to enhance code readability and make coding easier. However, too much detail can clutter the interface. With the new X-Ray feature for Scala, you can disable these hints and then double-press and hold Ctrl to toggle them back on when you need additional information. This allows you to keep the editor clean until you want to consult the hints.

Scala settings are now easily discoverable through text search. In the Find Usages pane, we've added the File Structure button, allowing you to access more comprehensive information about how specific elements are used within your codebase. To improve the readability of your code, the Structure tool window now uses ?=> to distinguish implicit parameters from regular ones. We've also introduced new icons for runnable objects, test classes, exception classes, and enums in both the Structure and Project tool windows.

We have enhanced IntelliJ IDEA’s support for the Scala CLI in several ways. First, you can now use auto-completion for using directives, and when you do, their elements are automatically formatted and highlighted correctly. Second, when you auto-import a symbol, it will be seamlessly integrated into the file under the using directives, resulting in cleaner and more organized code.

Previously, the Scala plugin included transitive dependencies among the direct ones, leading to instances where unnecessary project dependencies were considered. The plugin now calculates all transitive dependencies while importing or reloading. This revised approach gives you more control over the project structure. We’ve ensured that sbt modules correctly depend on the standard Scala library, eliminating any instances where they might mistakenly rely on the Scala SDK. Additionally, we've addressed the issues that were causing disruptions in the sbt command history when importing or reloading sbt projects, and we've improved the process for fetching available Scala and sbt versions when creating a new project. Also, we've made a decision to drop support for the sbt-android plugin starting with this release.

Expanding the GitLab integration introduced with the IntelliJ IDEA 2023.2 release, we’ve added support for GitLab snippets. You can now create public or private snippets directly within the IDE. To create a new snippet, select a code fragment in the editor (or a file or folder in the Project tool window), right-click on the selection to call the context menu, and choose the Create Snippet option. A dialog will appear, prompting you to provide general information about your snippet and define its privacy settings.

IntelliJ IDEA 2023.3 introduces a revamped way to review changes. Now, instead of going through each file one by one, you can see all of the modified files from a changeset in a single scrollable frame. This new diff viewer is compatible with GitLab, GitHub, and JetBrains Space reviews.

Gradle projects now open faster because the IDE no longer automatically downloads the source JAR files for all dependencies. If you need to access specific source files, you can navigate to them using the Ctrl+B shortcut and opt to download them when prompted by the IDE.

We’ve enabled the new fast Maven project import mechanics for all projects, including ones created using the older import implementation. This significantly improves the import time. The first time you open a project in version 2023.3, the IDE will perform a full resync and notify you about the migration. You can adjust this setting in Settings/Preferences | Build, Execution, Deployment | Build Tools | Maven | Importing.

We’ve revamped the way the IDE handles the grouping of project modules. Now, it automatically groups modules based on their qualified names. If you need to, you can manually rename modules, and these names will persist during subsequent reloadings of Maven projects.

Maven 3.9.3 is now bundled with IntelliJ IDEA.

The IDE no longer supports Maven 3.0.

We’ve improved the Structure tool window in the HTTP Client to streamline navigation within large .http files. This update introduces color-coded labels for request types and lists their contents more clearly.

The HTTP Client now supports declaring variables using @. You no longer need any extra environment files to reuse values across requests, and the IDE provides code completion for the values so you can easily add them.

The HTTP Client now provides support for authentication with the OAuth 2.0 Password and Client Credentials grant types. With this update, you can reference authentication data in your requests using the new syntax {$auth.token("my-keycloak1")} and navigate to the JSON file containing the authentication details. This change streamlines the request execution process, eliminating the need to manually retrieve tokens. Learn more.

We’ve implemented visual editing capabilities to help you quickly compose well-formatted OpenAPI specifications using live templates. These actions are available for both YAML and JSON files. To insert a template for an object, simply hover over the relevant line in the gutter and click the + icon.

The integrated version of Swagger UI has been updated to 5.0. You can switch between Redoc and the updated Swagger UI preview in OpenAPI files via the floating toolbar action. As of v5.0, Swagger UI also supports OpenAPI 3.1 specifications.

We’ve improved the code completion functionality for handling URLs. Now, when you type / in places where a URL path is expected, the IDE automatically populates the code completion popup with the URLs of server endpoints. When doing so, it considers both available APIs within your application and attached OpenAPI specifications to help you specify the URL path more quickly.

You can now use the Run with Coverage and Profile with IntelliJ Profiler run configurations for Quarkus projects. Both run configurations can be conveniently accessed directly from the Run widget.

Support for Spring 6.1 features has been extended. For the new RestClient, the IDE now offers full support, including URL autocompletion, the Find Usages functionality, and the ability to view all client usages in the Endpoints tool window. In addition, we’ve implemented SQL highlighting and parameter name code completion for the new JdbcClient. IntelliJ IDEA Ultimate now also recognizes the @Scheduled scheduler attribute, providing completion suggestions and validation for bean names used within this context.

We’ve introduced a new Spring GraphQL plugin that adds several valuable features for developing Spring applications built with GraphQL Java. When the plugin is installed, the IDE offers code navigation and completion suggestions for Spring GraphQL, as well as schema mapping. You can also navigate to GraphQL schema implementations and view them in the Endpoints tool window.

IntelliJ IDEA Ultimate 2023.3 offers an enhanced user experience when working with databases hosted in Kubernetes. For example, you can now configure port forwarding within Kubernetes while establishing a database connection.

The IDE can now identify references to specific YAML schemas included as comments. It also provides code completion and syntax validation within YAML files based on the specified schema, regardless of whether it’s stored locally or accessed remotely.

With IntelliJ IDEA Ultimate 2023.3, you can easily add kubeconfig contexts from clusters located in directories outside of the required system. The project will include links to kubeconfig files, making these clusters available while you work on your project. The kubeconfig contents added in this way won’t be copied to or modified in the system (~/.kube/config). This feature is especially useful when you frequently add and remove Kubernetes clusters from cloud or on-premises environments. Learn more.

When you start using the Kubernetes plugin, which is now bundled with IntelliJ IDEA, you may need to install kubectl and/or Helm. If you don’t have them on your computer already, the IDE will offer to automatically install them for you.

Telepresence allows you to debug the microservices of a Kubernetes application locally, as if your workstation were a part of the cluster. By connecting to the cluster using Telepresence, you gain access to the cluster’s namespace from your workstation and can interact with the DNS names of other microservices. With Telepresence interception, you can redirect traffic from other cluster services to selected ports on your workstation and debug microservices entirely locally using familiar IDE tools.

In this release, we’ve made the Telepresence workflow more accessible by moving it to the cluster’s context menu. We've also streamlined interception management for a smoother debugging experience.

IntelliJ IDEA Ultimate 2023.3 supports top-level import blocks from version 1.5 of the Terraform configuration language. import blocks allow you to bring the current infrastructure under Terraform’s management. When import is used within a code block, it becomes part of the standard plan and apply stages and ceases to be a state operation. Terraform performs automatic code generation for imported resources, saving you time when developing infrastructure as code.

To boost the IDE’s startup speed, we’ve made the download of shared JDK indexes the default. IntelliJ IDEA will now seamlessly connect to a dedicated resource in the background, fetching and applying shared indexes for your JDK automatically.

IntelliJ IDEA Ultimate 2023.3 integrates the Lets-Plot library for streamlined, no-code data visualization.

IntelliJ IDEA 2023.3 offers reworked import functionality, marking the completion of the transition to the new Modify Object UI. It is now possible to import to multiple targets and make simultaneous edits, such as by changing the formats or encoding for several files or altering schemas for multiple targets.

This release introduces a number of updates for introspection:

• Introspection intervals for each data source.
• Automatic introspection level for Oracle.
• Support for new objects in SQL Server: partition functions, partition schemes, partitions and related table and index properties, ledger tables, and filegroups.
• Support for materialized views in Redshift, which are now introspected and displayed in a dedicated node.

IntelliJ IDEA Ultimate 2023.3 solves some of the inconsistencies with adding import type statements. We’ve added the option to configure the usage of the TypeScript import type statement or type specifier when importing a type. We’ve also improved the behavior for the exports field of package.json for TypeScript files.

We’ve added support for defineSlots, providing completion and navigation for the slot name, as well as rename refactoring. We’ve also introduced completion support for properties with defineExpose. In IntelliJ IDEA Ultimate 2023.3, required imports for components will be added based on the name specified by the defineOptions function.

We’ve improved support for strict template type checking in Angular templates. We’ve also supported the new control-flow syntax from v17 and signals, including live templates like signal, computed, and effect. There are also new quick-fixes available with Alt+Enter. For example, you can create @Input and @Output properties from a component template.

IntelliJ IDEA Ultimate 2023.3 brings new capabilities for testing your JavaScript code. Cypress and Playwright tests are now automatically detected and can be run from a Run icon in the editor. We’ve also introduced initial support for the native Node.js test runner. Tests declared with the node:test API are now recognized, enabling running and debugging directly from your code without extra packages.

Navigate from a repository or code review in Space to the corresponding files in your IDE via the Start coding button.

IntelliJ IDEA 2023.3 now recognizes Maven packages hosted in Space repos and suggests them in the code completion pop-up.

Starting with IntelliJ IDEA 2023.3, we’ve made changes to plugin distribution. The Android, Ant, and GlassFish plugins are now available through JetBrains Marketplace. This also applies to the XPathView plugin for IntelliJ IDEA Community Edition.