Released: Dec 8, 2025

2025.3 での更新項目

機能

• Open and integrated AI experience
  • Multi-agent experience: Junie and Claude Agent - Now, multiple agents are available from the same chat interface, allowing you to switch between them and get the right kind of assistance for every task.
  • Transparent in-IDE AI quota tracking - You can now view your remaining AI Credits, renewal date, and top-up balance directly inside IntelliJ IDEA.
  • Bring Your Own Key: More freedom and control - Coming soon - With BYOK, you will be able to connect to OpenAI, Anthropic, or any OpenAI API-compatible local model using your own API key, without logging into JetBrains AI.
• Unified distribution
  • Starting with the 2025.3 release, IntelliJ IDEA Ultimate and Community Edition have become a single unified product - with one installer and one update stream. In this new setup, an Ultimate subscription unlocks access to all the advanced professional features you are used to.
• Command completion
  • IntelliJ IDEA 2025.3 introduces command completion - a new way to access context-aware actions directly from code completion.
    • Type . to see code completion and postfix completion suggestions, as well as actions.
    • Type .. to filter the results to actions only.
    • Select an action to see the exact context and preview what the action will do if applied.
• Spring Boot 4 and Spring Framework 7
  • Support for the latest improvements in Spring Framework 7 and Spring Boot 4. Improvements to REST API versioning, programmatic bean registration, and declarative HTTP service clients.
  • API versioning: Ship multiple APIs safely without breaking clients - IntelliJ IDEA makes the versioning process even smoother by validating version formats, flagging ambiguous or misconfigured endpoints, and generating the necessary configuration. Additionally, HTTP request generation and navigation between client and server also respect versions, keeping everything in sync.
  • HTTP service client: Call external HTTP services easily - When your app needs to call another REST service - a daily task - you can now create the client with almost no setup. Since Spring Framework 6, it's been possible to define a plain Java interface and mark its methods with HTTP annotations, but you still had to configure the underlying client implementation. In Spring Framework 7, the process is even simpler. Just add an interface and a few annotations, and you're good to go - no factories and no customizer beans. IntelliJ IDEA builds on this process. It warns you if a client interface isn't configured properly, helps you use client interfaces in code, and supports navigation and HTTP request generation.
  • Bean registration API - Spring Framework 7 makes registering a bean as simple as implementing BeanRegistrar with a concise DSL. IntelliJ IDEA's advanced code analysis now even understands Spring 7's dynamically registered beans. Additionally, the IDE marks registered classes with the Spring bean gutter icon, lets you navigate to where the bean is registered, and runs inspections to catch registration issues early.
  • With the Kotlin DSL, you can group related beans together, register them conditionally, or reuse registration logic just like any other Kotlin function, keeping configuration modular and maintainable. Combined with the routing DSL's flexibility for defining APIs with conditions, loops, and nesting, Spring applications gain a unified, Kotlin-native style that is both expressive and efficient.
• Spring Data
  • Spring Data JDBC support - As Spring Data JDBC is gaining popularity, IntelliJ IDEA brings support on par with its support for Spring Data JPA, enabling you to:
    • Generate entity classes from existing database tables, including those with composite keys.
    • Generate DDL from your Table classes and enjoy support for Liquibase and Flyway.
    • Compare your code model with the database and create scripts to align them.
    • Create Spring Data repositories on the fly and wire them into your code instantly.
    • Get smart completion for Spring Data repository-derived query methods.
    • Add table columns directly into your entity classes via completion.
  • Spring Data repositories: Take advantage of Ahead-of-Time compilation - Recently, the Spring Data team announced AOT code generation for Spring Data repositories, which improves performance and makes debugging easier. This is particularly useful for debugging derived query methods, which used to be challenging because they were generated from method names on the fly. With AOT, you can see the queries that will run before execution, and execution itself is faster because code is already generated. IntelliJ IDEA 2025.3 enhances this improvement by detecting generated implementations for Spring Data repositories and showing the queries right in your code. The IDE lets you navigate to the query execution code so you can set a breakpoint and trace the flow. You can also execute generated queries directly in the IDE without running the application.
• Spring Debugger updates
  • You can now debug remote applications. Simply start your app with a debug port open, and then attach from the IDE. Also added another highly anticipated feature: IntelliJ IDEA can now automatically connect to your database when the application starts.
• Kubernetes experience improvements
  • Stay in context with the cluster and namespace selector at the top, and spot issues fast with live resource status icons. Struggling with missing env variables or failed pods? Fix them instantly with one-click logs and redeploy without leaving your manifest.
  • Secure your service setup with in-editor secret management. View and copy database credentials directly from your YAML.
  • Need to connect? Use one-click port forwarding to forward container ports, autoload secrets, and set up an instant connection to your database or service in seconds.
• Java 25
  • Released in September 2025, Java 25 is the next Long-Term Support (LTS) version of the Java platform. IntelliJ IDEA has supported Java 25 from day one of its release, ensuring developers could immediately benefit from the latest language, runtime, and tooling enhancements.
  • This release adds the finishing touches to this support - making sure all bundled tools and libraries, including Async Profiler 4.1 and JaCoCo, are compatible with Java 25 runtimes.
  • JDK 25 builds from all major vendors - Oracle OpenJDK, IBM Semeru J9, GraalVM, and Microsoft Build of OpenJDK - are available for download directly from IntelliJ IDEA.
• Develocity IntelliJ plugin
  • The Develocity IntelliJ plugin brings profiling into the build process. With it, you can view detailed build characteristics directly in IntelliJ IDEA, identify performance bottlenecks, and observe how build changes affect speed and resource utilization. No modifications to build scripts are required - simply enable the corresponding setting in the plugin.
• Islands theme
  • The Islands theme is now the default look in IntelliJ IDEA. Recognizable tabs, improved in-editor contrast, separation between working areas, and rounded corners.
• Vitest 4 support
  • This release adds full support for Vitest 4, including its test discovery logic. Test files and individual test cases are now recognized in the editor, with gutter icons that let you run or debug them instantly. The integration also accommodates the latest Vitest configuration options and reporting changes, so you can upgrade without disrupting your workflow.
• Databases
  • Starting from the 2025.3 release, IntelliJ IDEA replaces the term query console with query file - because consoles have essentially always been files.
• Development stack - IntelliJ IDEA 2025.3 introduces support for:
  • JUnit 6, bringing modernization and unification across the testing ecosystem. It standardizes artifact versioning for all JUnit modules and raises the baseline to Java 17. In Spring Boot 4 and Spring Framework 7, JUnit 6 is now the default testing library, helping you adopt the latest best practices more easily.
  • Gradle 9, introducing the Configuration Cache as the preferred execution mode for faster builds and a smoother developer experience. You'll also benefit from many performance improvements and quality-of-life enhancements across the toolchain.
  • Groovy 5, now targeting JDK 11 and offering improved compatibility with Java 25 language features for a more cohesive experience when mixing Groovy and modern Java codebases.
  • Scala 3.8, adding the new into modifier, a standard library compiled with Scala 3, and an updated minimum JDK requirement of 17. You can learn more about the enhancements to Scala support in this overview.