What’s New in IntelliJ IDEA 2024.3

The Structure tool window now includes a Logical code structure alongside the familiar Physical structure. This allows you to view not only classes, methods, and fields but also the links and interactions between components in your project. For example, when you open a controller in a Spring Boot application, you can see its endpoints and the autowired application components. This enhanced view helps you understand the project structure and allows you to navigate through the project by following both code usages and meaningful connections.

We've made debugging Kubernetes applications even easier. You can activate tunnel debugging simply by clicking on the ellipsis next to the Debug button and selecting Add Tunnel for Remote Debug. This makes your workstation a virtual part of the Kubernetes cluster, allowing you to swap in a pod and debug microservices locally with your preferred tools. Other microservices will interact with your workstation as though it's the pod you're debugging, with full network access to the rest of the cluster. Even non-Kubernetes-aware debuggers work flawlessly. Additionally, the new Forward Ports section in the Kubernetes UI under the Services tool window simplifies port forwarding.

IntelliJ IDEA now offers cluster-wide Kubernetes log access with streaming and pattern matching – essential tools for developers, as well as DevOps and SRE teams. This feature provides a centralized view of all events across pods, nodes, and services, helping you quickly identify issues without manually checking each log. Real-time streaming enables immediate diagnostics, while pattern matching automates the detection of key events and errors, such as out-of-memory issues or unusual network activity. Learn more about this feature and how to use it in this blog post.

In IntelliJ IDEA 2024.3, K2 mode has officially moved out of Beta and is now Stable and ready for general use. K2 mode significantly improves Kotlin code analysis stability, memory consumption efficiency, and the IDE’s overall performance. K2 mode now offers improved feature-parity with Java, and support for all Kotlin 2.1 features. To explore its capabilities, go to Settings/Preferences | Languages & Frameworks | Kotlin.

In this update, we’ve made managing the context AI Assistant takes into account with its suggestions more transparent and intuitive. A revamped UI lets you view and manage every element included as context, providing full visibility and control. The open file and any selected code within it are now automatically added to the context, and you can easily add or remove files as needed, customizing the context to fit your workflow. Additionally, you can attach project-wide instructions to guide AI Assistant’s responses throughout your codebase.

You can now select your preferred AI chat model, choosing from Google Gemini, OpenAI, or local models on your machine. This expanded selection allows you to customize the AI chat’s responses to fit your specific workflow, offering a more adaptable and personalized experience.

In addition to cloud-based models, you can now connect the AI chat to local models available through Ollama. This is particularly useful for users who need more control over their AI models, offering enhanced privacy, flexibility, and the ability to run models on local hardware.

To add an Ollama model to the chat you need to enable Ollama support in AI Assistant’s settings and configure the connection to your Ollama instance.

IntelliJ IDEA now gives you the option to use compiler-based type inference for transparent inline method calls in Scala 3. This enhancement improves support for libraries that rely on macros, unlocking all type-based features (such as code completion, navigation, type hints, etc.) for macro-based code. The feature is currently experimental.

IntelliJ IDEA 2024.3 offers full support for named tuples, a new experimental feature in Scala 3.5 that will become a standard feature in Scala 3.6. As the title suggests, named tuples allow you to name the components of a tuple so that they can be accessed with readable names.

Additionally, IntelliJ IDEA is better at recognizing opaque types. It was already able to recognize the opaque keyword, but in practice, IntelliJ IDEA has handled opaque types just like standard (i.e. transparent) type aliases. Opaque types are now handled as abstract types, hiding their underlying definitions.

We reduced the number of cases when multiple compilations were necessary. For example, in instances where refactorings that affect multiple files result in many compilation requests. In the new release, IntelliJ IDEA analyzes and batches these requests and then issues a single request with a wider compilation scope. This reduces CPU resource utilization and optimizes the compiler’s highlighting experience.

We’ve also fixed some edge cases where duplicated parser errors are shown, both from the IntelliJ IDEA Scala parser and from the compiler.

Building on the progress made in the 2024.2 release, we’re increasing the number of essential features that are available while the project model is being built and indexed. In version 2024.3, spelling and grammar checks are accessible even while indexing is in progress. This allows you to catch errors, such as those in Markdown documents and documentation tags, without waiting for indexing to finish.

The updated Run widget lets you launch multiple configurations simultaneously by holding Ctrl and clicking the Debug icon in the popup. Additionally, the widget displays controls for all running configurations, providing a clear overview of their statuses and simplifying management.

We’ve optimized the placement of the Rename action in the context menu when called on elements in the editor and the Project tool window. The action is now at the top level, making it easier for users who frequently rely on the mouse to quickly rename files, variables, and other elements.

By default, IntelliJ IDEA will now automatically highlight all instances of the text you select within a file. This makes it easier to track where the selected text appears throughout your code. If you prefer the previous behavior, you can disable this feature in Settings | Editor | General | Appearance.

The New popup for adding files to Java source roots now displays only the most relevant options, reducing clutter and streamlining your workflow. If you prefer the previous extended list of templates, you can easily restore it by going to Settings | Advanced Settings | Java.

Committing changes directly from the editor is now faster and easier. After editing a line of code, click the marker in the gutter. In the popup that appears, you can amend the change or make a new commit, and you even have the option to add a commit message right there.

AI Assistant now helps generate accurate titles and descriptions for your pull and merge requests directly from the IDE, streamlining your workflow and ensuring your descriptions are clear and concise.

The Find in Files feature has been enhanced with a new search scope, Project Files Excluding Git-Ignored. This option excludes any files ignored in .gitignore files from your search results, helping you focus only on the relevant code when searching through your project.

You can now manage background checks during the commit process with a new Run advanced checks after a commit is done option under Settings | Version Control | Commit. This setting lets you decide if tests and inspections should run after making a commit. If you want these checks to be completed before the commit happens, simply disable it.

We’ve made using the HotSwap feature easier and more intuitive. This feature allows you to reload modified classes during a debugging session without restarting the application. Now, when you edit code with an active debugger session, IntelliJ IDEA automatically detects the changes and prompts you to reload them via a convenient button in the editor. This streamlines the development process by enabling real-time code updates. Keep in mind that HotSwap has some limitations, particularly with structural changes. You can learn more about them here.

You can now set exception breakpoints from the editor. While at the throw or catch site, open the context menu via ⌥↩ on macOS or Alt+Enter on Windows/Linux, and then select Enable exception breakpoint. This new feature makes setting exception breakpoints more convenient, as you don’t need to open the Breakpoints dialog or browse the stack trace in the console.

IntelliJ IDEA 2024.3 eliminates the need to clutter your code with logs and timers when you want to measure the execution time for a bunch of lines. After invoking the Run to Cursor action, you will see the execution times for each line right in the editor’s gutter. For deeper analysis, use the same hints in the gutter to drill down to the called methods, whose respective lines will also be accompanied by execution time data.

IntelliJ IDEA 2024.3 addresses the challenges of troubleshooting asynchronous code, where tasks are scheduled in one thread and executed in another, with each maintaining its own stack trace. The IDE now prints a merged stack trace in the console instead of only the worker’s stack trace, making it easier to trace the flow of execution. This enhancement is enabled by default for tests.

We’ve made parallel compilation the default in IntelliJ IDEA 2024.3. In previous versions, project modules were compiled one at a time, which wasn’t the fastest approach for large projects. Now, you will see faster compilation times for all Maven-based projects compiled by the IDE, with optimized CPU and memory consumption.

IntelliJ IDEA now automatically detects SSL-related issues during Maven syncs and builds. If an untrusted certificate is the cause, the IDE will offer to resolve it by trusting the certificate – no manual steps required. This update eliminates the guesswork of combing through logs to find cryptic SSL errors and removes the need for tedious manual certificate management in the JDK’s trusted store.

We’ve added full support for Maven’s split local repositories – a feature introduced in Maven 3.9. It allows you to separate local repositories according to your needs. You can group them by remote repository, store locally installed artifacts in a dedicated folder, or even categorize artifacts by branch using specialized prefixes. Previously, enabling split repositories in Maven could cause sync failures in IntelliJ IDEA, leading to build or dependency issues. Now, full support ensures smooth syncing and efficient repository management.

The first public EAP release of our new Bazel plugin for IntelliJ IDEA is now available. The plugin currently lets you open Bazel projects for Java and Kotlin, supports building, testing, running, and debugging Bazel targets, and offers Starlark syntax, completion, navigation, and debugging support.

IntelliJ IDEA now offers improved support for Spring Boot Actuator. When Actuator is enabled, you can access more runtime information in the IDE. First, a new Environment tab in the Run/Debug tool window shows the variable values used by your application, including system properties, environment variables, and configuration properties.

Additionally, you can now see which conditions were triggered at runtime for bean instantiation, which can be especially useful when debugging an application to understand why a bean isn’t working. Furthermore, a new gutter icon highlights any specific conditions that failed, helping you identify issues more quickly.

IntelliJ IDEA 2024.3 introduces the ability to access environment variables directly within the HTTP Client using the $env.ENV_VAR syntax. This allows for more flexibility when managing and using variables within your requests and scripts. In addition, it is now possible to import and run requests – either all at once or specific ones by name – from one .http file to another.

We’ve greatly simplified the experience of debugging GraalVM native images with Docker containers, which means you can now build and debug native Java applications on any platform. Simply specify one container for building your application and another for running it in the run configuration. Once the application is running, you can debug the app not only in the Java code but also at the assembler level. To make setup easier, we provide Docker images preconfigured with all the necessary software and libraries.

Support for OpenTofu is now available. This update includes autocompletion for encryption methods, key providers, and inspections for unknown references.

Terraform run configuration actions are accessible through Search Everywhere, and the IDE automatically detects unused variables and locals to keep your code clean. The controls for Init, Validate, Plan, Apply, and Destroy have been refined, and the Run Configuration form has been streamlined. Also, improved usage indicators and warnings for unused resources enhance navigation and help you identify inactive code.

Dev Containers builds now work more smoothly on remote Docker engines, preventing errors when local directories aren’t accessible remotely. Stability in WSL has also been enhanced, with improved image builds and reliable connections.

The devcontainer.json file processes features more consistently, and the new updateRemoteUID option avoids access conflicts by setting the correct user identity. IDE settings in Dev Containers can be customized through devcontainer.json files or via the Add currently modified settings from IDE button, with autocompletion for all available options.

IntelliJ IDEA 2024.3 provides extended support for Docker Compose. It now prioritizes .env files in env_file autocompletion, making environment setup faster. New build options – cache_to, no_cache, tags, and platforms – offer greater control over caching and platform targeting. Enhanced handling of depends_on.required and depends_on.restart allows for more effective management of the startup and shutdown order of dependent containers.

New keys like deploy.placement.preferences, deploy.resources.pids, and deploy.resources.reservations.devices allow for flexible service placement and resource limits. Multi-context builds and privileged builds are now supported via build.additional_contexts and build.privileged.

Additional options include cgroup configurations, custom extra_hosts mappings, and healthcheck.start_interval. Enhanced port settings and secrets.environment now streamline secret management via environment variables.

We continue to improve the reliability of projects that are hosted in the Windows Subsystem for Linux (WSL) and opened by developers from Windows in the IDE. In particular, we’ve introduced support for symlinks and improved performance by switching to Hyper-V sockets for interaction with WSL. We are continuing to work on significant platform changes to improve performance with remote environments, including WSL.

We’ve enhanced in-editor hints for Vue, Svelte, and Astro components. The Show component usages action now finds usages in both imports and markup templates. We’ve also added a Show Component Usages filter to exclude component usages when searching for regular file references. The Rename refactoring has also been updated with an option to include usages when renaming a component file.

We have improved the experience of working with AI Assistant in the editor. Now, when you ask AI Assistant to do something with a chunk of code, the editor area contains a diff with both the original and the generated code. AI Assistant’s suggestions are highlighted with a different color and marked with the Revert icon in the gutter. You can also edit the resulting query yourself in the diff. Your changes are highlighted the same way. For example, you can ask AI Assistant to retrieve more data with a query and then add an ORDER BY clause to the generated result.

A couple of useful new actions for handling SQL query execution errors with AI Assistant are accessible in the error message area. Explain with AI opens the AI chat with a prompt automatically sent and AI Assistant’s response with an explanation of the error. The Fix with AI action generates a fix for the query execution error in the editor.

In certain cases, running a query that contains an excessive number of JOIN clauses is not recommended due to performance degradation. The editor can now identify and highlight such queries. You can enable this inspection in the IDE settings. To do so, navigate to Editor | Inspections, expand the SQL section, and select Excessive JOIN count.

To make grid paging more noticeable in our data editor, we have moved the control for it from the toolbar to the bottom center of the data editor.

IntelliJ IDEA now supports fragment introspection. Previously, the introspector could perform only a full introspection of schemas in the MySQL or MariaDB databases but not refresh the metadata of a single object. Every time a DDL statement was executed in the console and that execution could modify an object in the database schema, the IDE would start a full introspection of the entire schema. This was time-consuming and often disrupted the workflow.

Now, IntelliJ IDEA can analyze a DDL statement, determine which objects could have been affected by it, and refresh only those objects. If you select a single item in Database Explorer and call the Refresh action, only one object will be refreshed, instead of the entire schema as it was before.

Linux users should note that, as of version 2024.3, global menu support has been discontinued in IntelliJ IDEA.