What's New in IntelliJ IDEA 2026.2

[00:00:09]Hey folks, and welcome to what's new in IntelliJ IDEA 2026.2.

[00:00:13]As always, I'm joined by my lovely colleagues, Marit, Siva, and Anton, who are going to walk you through the feature demos. In case you're interested in a more condensed offering, meaning a 90-second short video about all the new features, you'll also find that here on the channel.

[00:00:29]As we've got a lot to go through from AI to Java, Kotlin, and to Docker, let's jump right in.

[00:00:36]Which means, Anton, what's new in the AI world?

[00:00:39]>> Great.

[00:00:41]So, usually, we talk about models or agents. This time, we are going to talk about tools for the models and agents.

[00:00:49]Uh we have come the full circle, and uh this is something that our users were asking for for a long time uh to expose the tools from the IDE to make them available uh to the agents. And this sounds logical, but it's a little bit more complicated because if you give all the tools from the IDE uh the the agent might not be able to actually do anything with them because there's so many.

[00:01:17]>> What is a tool?

[00:01:18]>> A tool is, let's say, an action. Run the build, run the tests, uh refactor rename this variable. Um >> Set the breakpoint.

[00:01:28]>> Set the breakpoint. Replace text.

[00:01:32]Can also be what? Search for some symbol.

[00:01:35]So, all those actions, and there are thousands of them in the IDE, are tools.

[00:01:41]And we do expose them via MCP endpoint, and we used to expose them all separately. Uh so, if you go into the settings, there is a MCP server tools MCP server, which you can configure for uh any agent that you have connected to your ID.

[00:01:59]And, uh uh, there is a list of exposed tools. So, if you go to the list, we have this fancy solid 90s looking UI with, uh, with many, many, many, many checkboxes. And one of the new checkboxes that we have here is this router only checkbox. Which means that, uh, this this particular MCP tool will be hidden behind a single entry point. So, that the context is not polluted uh, with the tool descriptions because the context for the LLM is the single most precious resource.

[00:02:33]And, um, uh, so, so, and and if we expose all the tools, right? There is a lot of descriptions. They eat up the context.

[00:02:41]And, uh, usually you don't need all the tools. You don't You need a portion of tools depending on the task. Maybe debugging something, maybe writing tests, maybe investigating some some some problems, or anything. Uh, so, they usually are grouped, uh, and, uh, the universal entry point is, um, universal, is this execute tool that is also an MCP tool. And, uh, we need We need to teach the agents how to use those tools. So, the tools are there. They are exposed from the ID.

[00:03:18]Now, we need to tell the agents how to use them. And usually we do that using the agent skills. So, if you go into AI assistant configuration, there is a skills tab where we can configure the skills, or basically pull them in. There is, uh, default repository, or registry, which is github.com/jetbrains/skills.

[00:03:45]I usually disable it because there's too many tool too many agent skills, uh, definitions, and they are not, uh, not all of them are relevant to me. Of course, I can use the search, but the list is just too long and I have my own custom skills for Spectre and workflow for some specific things. So, I can usually configure that or I I also find some useful skills agent skills on the web.

[00:04:10]So, I can add those repositories into this configuration and once I have that, I have a list from where to install. So, some things are already pre-bundled for you like this IntelliJ debugger skill. We're going to have a very nice demo by Marit just in a moment. And there is a list of available skills that I can pull from my own repository. Now, if I click that one, I can in choose to install it either for either globally for all the agents or only for that project or only for for the specific agent. Maybe I have tuned it. I have not seen anyone tuning for the specific agent, but it's probably possible. Um yeah, so that's that's an important part.

[00:05:00]Uh and that's about tooling. So, we have tools.

[00:05:04]We need to teach the agents how to use those tools. For that, we use the skills manager and the skills register and agent skills.

[00:05:13]Uh and and the last update that we did recently a few weeks ago, there was an announcement of um GitHub Copilot team partnering with us on on improving the integration for for the Copilots and we have a blog about that as well. So, previously the GitHub Copilot was available through ACP registry.

[00:05:39]Uh but now it's bundled, so you can use your GitHub account to activate it and just use it without having the subscription for JetBrains AI.

[00:05:50]Uh yeah, that's it about >> And uh just to mention, essentially our end goal is with these tools, providing them the tools and the skills to make agents at the end of the day work faster, better, more deterministic, higher quality, right?

[00:06:05]>> This is what we are experimenting with and for us it's uh it's more like a go to be a platform to integrate the agents. We have ACP, agents integrate via ACP, and we expose our tools, our intelligence about the code, uh any other tasks that we can think of that are useful. And the team is working on experimenting, testing, evaluating how efficient they are. And for the users, the the benefit is that the agents are would get faster and they consume cheaper cheaper less less spending uh is always better.

[00:06:43]>> in in some aspects as well because it uses existing tools, so agents can have nice tools too.

[00:06:49]>> Yeah, agents can have nice tools too.

[00:06:51]>> And quality.

[00:06:52]>> Yes.

[00:06:53]>> Yeah.

[00:06:54]>> Great. Uh by the way, for you viewers out there, let us know how you work with skills. If you have like a company-wide repository for skills or project-wide skills or any other favorite skills you're using in your full-stack development, for example, let us know in the comments down below. All right. So, that means we're going to hop on to good old Java support. Marit, what's new?

[00:07:15]>> So, uh as you might know, our release falls squarely in between the Java releases.

[00:07:22]So, uh Java 26 was released in March and Java 27 will be released in um September.

[00:07:29]Uh so, obviously we will support Java 27 from day one, uh but there won't be a lot of uh language changes.

[00:07:37]Um so, in the meantime, uh we've shown this before, you can uh download uh Java 27 from inside IntelliJ IDEA, and also the Valhalla early access based on uh Java 27 if you want to try that out.

[00:07:54]Um but if you are using SDKMAN, like some of us are, right?

[00:08:02]>> Mhm.

[00:08:02]>> Um then you might be using a SDKMAN RC file, uh and if you remember, you can also download the the JDK from there. Uh and as of 2026.2, that works al- also if you don't have SDKMAN installed, which means that you can now use >> in even on Windows.

[00:08:24]>> Exactly. So, you can also use this on Windows if your project has an SDKMAN RC file, and you don't have that particular uh version of Java. In this example, I have the the 27 Valhalla.

[00:08:36]Uh you can uh download that from the SDKMAN RC file, even if you don't have SDKMAN installed.

[00:08:43]>> That's pretty cool.

[00:08:44]>> That is pretty cool.

[00:08:45]>> Cuz to install it, you have to go to command line, and maybe you are not command line person.

[00:08:49]>> Exactly. So, >> you have this descriptor in the project, and your colleagues can just download stuff.

[00:08:54]>> Yes. I mean, someone would have to add this file. So, if someone on the team does have SDKMAN installed, they can uh use SDK and init to create this SDKMAN RC file, and then everyone who uses the project can use that to download uh the right uh version of uh the JDK.

[00:09:12]Um however, in this example, uh we did another improvement for Java support, one that I really like. Uh in this project, I'm using Java 26, which is currently the latest version.

[00:09:24]Uh now, in my regular terminal, uh my default version of Java is still Java 25, which is the latest LTS.

[00:09:34]Um but in this project, I have uh Java 26.

[00:09:38]And what I want to show you is that that is now also propagated to my terminal automatically from my project settings.

[00:09:47]So if I open my terminal and that is both for my regular terminal and for my agent. So if I ask Claude for Java version.

[00:10:01]I'm sure there's a way to select that.

[00:10:03]If I ask Claude for Java version, it has Java 26. This means I no longer have to fight my agent on what Java version I'm using.

[00:10:12]>> Very annoying when you switch between the ID in the terminal.

[00:10:16]>> Yes, and it would fight me on that version is not out yet. Let me upgrade to you know an older version. So now you no longer have to fight your agent on what Java version you're using. The terminal will automatically inherit that from your project settings. And also if you're working on the terminal, it will also have the same Java version from your project settings. So I think that's super cool and helpful also with agents.

[00:10:43]>> It really is.

[00:10:45]Thank you Marit. Well, then we're going to have a look at Java's is it is it correct to say close cousin? Kotlin? I'm not sure, but we're going to have a look at Kotlin. What do you there Anton?

[00:10:54]>> Yeah, let's take a look at Kotlin.

[00:10:56]Kotlin had a 2.4 release meanwhile actually in May if I if I'm correct. And there are a few language features that the community was waiting for.

[00:11:11]The stable context parameters and the explicit backing fields.

[00:11:16]I will not dive deep into the language features themselves, but we did some improvements in the ID to you know start using those features. And uh let me go into the ID and to you uh the example. It will be very basic uh just to understand what the feature actually means. So, context parameters first.

[00:11:42]Uh context parameters are kind of annotations or requirements that we can add to the functions. So, I have a function that is called context function uh or some function. I could call it some function maybe just for for the example and to make the distinctions some function. Um and it's annotated with the special syntax where I declare that this function requires a context uh a context object or a context variable or a context parameter. We can call like use different names here uh that will be called, let's say, C.

[00:12:22]And it will have a type. A type interface, object, any class, or anything.

[00:12:28]So, some function needs to have a context object of uh type IContext. And that's an interface and I can supply any instances or any implementations of that interface as context objects.

[00:12:45]And in the use sites where I start using this function, let's say I'm just about to call this some function and give it an argument uh because it requires a context object when it's invoked uh you can see the IDE actually highlights it as an error.

[00:13:04]So, uh the the code does not compile. It actually forces you to provide this context object in order to invoke invoke the function.

[00:13:14]That's an interesting constraint and uh we have a special action to uh surround or to provide uh the context object for this function.

[00:13:26]Because currently I have the instance of that context object declared in the scope. So, uh the IDE will automatically surround the function call with this special uh context function.

[00:13:42]So, it looks like a block of code where where this function is invoked.

[00:13:48]Um when you look at this feature, uh it might be unclear why.

[00:13:57]Why? But, this is a functional way of um implementing dependency injection.

[00:14:04]So, this context object is a dependency in this example.

[00:14:10]There is a a more elegant uh and uh slightly more complicated example where the context objects are used. Uh that's for DSLs. This is where This is the bread and butter for for Kotlin, I think. Uh and I have an example here as well. So, I have a DSL implemented. I'm not going to dive uh into how it's implemented here, but you can see this nice uh structured code uh that looks like JSON almost. And uh it it builds a in an instance of a client.

[00:14:43]And the client has a first name, last name, some uh other attributes like Twitter handle, uh maybe TikTok account, and and so on. But, they do also have uh a birth date. Usually and uh in this DSL that I have created for myself, it's a demo code. Um I have a date of birth uh field that I will declare as 24th of March.

[00:15:08]Uh maybe 1990.

[00:15:12]And this code should does not does not seem to compile. What's going on?

[00:15:21]Because currently March is an extension function on an integer.

[00:15:27]So, it's an extension function on an integer and it's also an infix function.

[00:15:35]It looks cool, reads cool, but we don't want to pollute the global scope. So, integer is a global type. We don't want to this new extension function to be to be available on any number.

[00:15:52]I want it to be available on the number only if I'm building the client.

[00:15:57]So, only where it makes sense. And as you can see, the compiler is yelling at me.

[00:16:03]So, why? Because I have declared this function with the requirement that it needs to happen within the context.

[00:16:11]The date context.

[00:16:13]And uh the the context is this block of code.

[00:16:20]And I need to declare that this block of code contains this context. And I can do that by declaring this um date context for for the block of code in the declaration in the signature for this function for for the parameter of this function. And then the compiler uh satisfy is satisfied for the uh for the invocation right here when we declare the date of birth. But then it also yells at me that I don't have this context inside uh this builder function that invokes this block of code. And of course, I I'm in control of this code and I'm going to provide this date context myself. Like I need to fix this code a little bit. Yeah.

[00:17:15]So, uh why is this uh important? Because uh extension functions can appear on global types, and we want to control the scope of them, and I don't want my users to um read the documentation about DSL. I want the tooling to uh help my users to to use my DSL and uh prevent from stupid mistakes like uh using functions that don't exist that are not supposed to be used from from outside of the context and so on. So, it's like me uh the the the author of the library, the author of the DSL uh can control and can guide the user with the help of the compiler and the IDE tooling as well.

[00:18:04]Uh but, this is a complicated thing.

[00:18:07]Uh so, if you look at the simple example, it feels why?

[00:18:12]But, uh if you go into more complicated example, then you suddenly understand that uh well, this is a great feature to control the scope of those fancy features in in Kotlin. Um yeah, that's that's the main thing that the community was waiting uh for, especially the Android uh developers, because there is a lot of DSL uh in Android development, and uh the other feature that we uh added is about explicit backing fields. So, uh in Kotlin, you have it's a very common pattern that you want to expose something as non-readable uh variable or a collection or anything like that, but internally inside the class, you do want to add uh some elements there depending on the logic. And the pattern was that uh people would declare some private variable as mutable list, for instance, and uh expose it via immutable list uh and and inside the getter for this uh property, they would uh uh return that mutable instance. So, that outside you don't outside of the class, you see it as immutable something, but internally it is mutable.

[00:19:36]Um and this requires declaring two fields, and it's annoying like for for people, and it seems like it is a pattern, and the team was working on simplifying that. So, as soon as the IDE uh recognize it recognizes this kind of pattern, we have this intention uh inspection to hit Alt Enter and convert it into one single field with the new syntax, uh which reads uh reads well, I would say. Uh you just uh just have to know how to read it that the the the property itself is is in immutable, and but internally it will be mutable field.

[00:20:19]So, uh but yeah, it's it's just a language feature, but inside the IDE we have those new actions to convert to the new syntax and back to the uh old pattern.

[00:20:33]Yeah.

[00:20:34]>> Thank you, Anton.

[00:20:35]Then, on from language features to a feature which I'm pretty hyped about. Uh it's called log points or print line debugger, and uh Marit is going to show us all about it.

[00:20:45]>> Yes. It is super cool.

[00:20:47]Uh so, imagine you're a developer in a web shop, as you are, and you have this order service and order processor.

[00:20:56]Uh and obviously you test your features before you push them to production, right?

[00:21:01]So, let's uh add some load on uh our service, and then when we go to the run uh window, we see that orders are being processed and some of them are failing.

[00:21:13]So, we need to figure out why they're failing.

[00:21:17]But if we go to the debug window, we don't have any information on what's going on.

[00:21:22]Uh so, we need more information. One way to do that would be to add system out print lines or log statements, but that means then we have to change our code, redeploy our code. We might end up with a different runtime state. Uh I love a good Heisenbug, don't you?

[00:21:37]>> Yep, we all do.

[00:21:38]>> Yeah, no. Um really really really don't.

[00:21:41]So, what we can do instead now is that we can add a log point.

[00:21:45]And there we can uh put an expression request.

[00:21:50]And that's an editor, so it we have code completion here. And then as I'm typing that, you can see that it's showing up and it's now logging lines from this uh log point. So, you know, sometimes naming things is hard, sometimes we get it right. Um so, uh this will uh generate additional logging so that we can figure out what's going on.

[00:22:11]Um another uh upside of using log points is that obviously in your libraries, we go to uh where this method is called. In our libraries, obviously we can't use system out print lines or or add log lines, but we can use um log points there. So, here again we can uh add a log point and let me just yell that this is the body.

[00:22:43]body Uh and then we will show see that showing up in our log. And then uh that can help us get more information about what's going on. And then if we see something interesting in our log, uh let me look for example, we have some orders with quantity zero. That can't be right.

[00:23:01]Uh we can actually if we click it, we get the hints that we can on Mac command click it and then we go to the place where that log line is created so that we can then continue our investigation uh from there.

[00:23:16]Uh in our case uh because it's a demo, I know why it's failing uh because it has quantity zero. So, I also know where to fix that.

[00:23:24]But, usually the hardest part or one of the hardest parts of debugging is knowing where to put the breakpoints in the first place.

[00:23:32]Uh so, as Anton showed, we have a debugger skill. Uh so, let me try that.

[00:23:39]Uh we can use the IntelliJ debugger skill and then uh let me paste the the description so that I don't have to type. So, we can actually ask the debugger to help with our uh debugging. It's going to hopefully find the tool. Sometimes it finds them immediately, sometimes it doesn't. Or rather, for me it usually doesn't find them and then one of my colleagues says, "Oh, for me it always finds them." So, I'm like, "Okay, fine. We'll ship your machine then." I guess.

[00:24:08]Um but, you know, it's going to eventually find the MCP idea execute tool. So, one of the tools that we we've seen.

[00:24:16]Uh but, I've already of course done this. So, let's find a previous chat where I've done this. So, um it will look at use the tools and it will actually it notices that there's a debug session already running. So, it might not do the same thing every time.

[00:24:34]So, this is just what it what it did uh some of the times.

[00:24:37]>> state of the project, right?

[00:24:38]>> The state of the Well, you know, it's it's AI. It's non-deterministic. That's what makes it easy.

[00:24:44]>> of the stars and the time.

[00:24:45]>> the moon, the color of your socks, whether Mercury is in retrograde, I don't know. Um so, uh it found the HTTP file of the orders that we're firing on on the the service.

[00:24:57]Uh and then at some point it it has a uh theory of what's going on, and then it starts actually validating that theory and and collecting information, curling stuff. Thanks Daniel for curl.

[00:25:10]And then eventually So, here we can actually see that it put a breakpoint, and you can interact with the debugger. So, you can also watch as it's debugging and and see what's going on.

[00:25:25]But eventually it will find the root cause. In this case, it found it's failing because quantity is zero.

[00:25:32]It collected all of the data, etc. So, yeah, it's really useful in in the debugging. It it provides you all of the information of of what it did and and the steps that it took to get there.

[00:25:44]Usually, I think it will also clean up the breakpoints again, but if not, you can set them and then run the debugger yourself and run the scenario through the debugger if you want to verify yourself.

[00:25:55]But yeah, that can really help, I think, with debugging stuff if you don't even know where to start.

[00:26:00]>> It looks very much like like the human would debug the application first, find where it is, put all the print line statements, and see, "Oh, okay, the first one, the second one appeared in the log, and the third one did not. So, it seems like something in between is broken."

[00:26:17]>> Yeah.

[00:26:18]>> And and and then start investigating.

[00:26:20]>> I mean, logging, I reached here one, I reached here two.

[00:26:24]So, that's why it's there.

[00:26:25]>> Yeah, but now you don't have to do the print lines anymore. You can just do the log points. I made it here. I made it here. I made it here.

[00:26:33]Or you can ask use the use the skill, and that will maybe get there faster without having to do all of those. So, I think that can be super useful.

[00:26:41]>> It can be. And that's a call for feedback. We've been working on this for quite a while. Please do try it out.

[00:26:47]Log points and the skill, and let us know uh, your experiences with it.

[00:26:51]Down in comments below, just send us an email, you track ticket if there is a bug. Uh, we appreciate all the feedback.

[00:26:57]>> Yes. Thanks.

[00:26:59]>> Then, let's talk a bit about, um, frameworks, more specifically about uh, Spring and Flyway. What's new there, Siva?

[00:27:06]>> So, we continue improving the Spring Boot support and, uh, we have added some pretty cool features in, uh, Spring Debugger. So, let's say you are building a REST API and you are using Spring Security to secure the API endpoints. And now, let's imagine you want to debug some functionality that is already secured. And, uh, usually the way you go about it is like you find the credentials and then you invoke a, uh, login endpoint and you get the token and then you pass it. So, most of the times by the do you, uh, do all these things, you forget why you started doing all these things. So, now you don't have to do all these, uh, things. Instead, you can start the application in debug mode and here, right away, you can see the security inlays like which endpoint is secured by, uh, what kind of a role you need to, uh, invoke that particular endpoint.

[00:27:58]Here, as you can see, these endpoints are secured by, uh, admin role and this can be, uh, invoked by anybody, anonymous user. And also, if you take a look at the other post controller here, this can be invoked by any authenticated users. So, immediately the, uh, inlays convey that what kind of a role is able to invoke this API endpoint. But, that is just one thing. The coolest thing is now you can simply unlock and then invoke this API endpoint. You don't have to actually login with, uh, credentials.

[00:28:31]So, let's say this API endpoint is to fetch all the users, which only admin can do it. So, now you don't want to do all this, you just want to, uh, invoke this, maybe you want to some, uh, do some debugging and all that. So, now you can simply unlock this and here you can see the lock icon is open and let's say we go to HTTP client and here also you can see the inlets information where it shows you can invoke this API endpoint.

[00:29:01]Now, simply call it and you get the information. So, as simple as that.

[00:29:05]>> That's super powerful.

[00:29:06]>> Yeah. And here in this case we are not storing any authenticated user information, so we don't need to specify which user is actually invoking this, but consider what if we are trying to create a new resource like creating a new post. In this case, we want to store the user ID who is actually creating this new post. So, in this case we might want to specify which specific user we want to simulate. So, here we have another option where I can say, "Hey, this is the username and I want to log in as an admin or whichever role you want to use." And you can say you unlock that API endpoint and you set what are the credentials that you are going to use. Now, you can invoke that API endpoint without actually providing this authentication token or anything. So, you can just invoke this and you can see that is stored correctly. So, this is going to be really helpful if you want to debug and you don't want to go through all the security filters and everything.

[00:30:15]This is really nice and as you can see this is nicely integrated between your Java code and also your HTTP client.

[00:30:24]Right away you can either you can unlock from the controller endpoints or you can directly unlock from the HTTP client itself.

[00:30:32]>> And also a shout out to our HTTP client.

[00:30:35]But it's so nicely integrated with all these technologies.

[00:30:38]>> Yes. In addition to getting the auto completion and everything, you can also see the security endpoints and how to unlock and all those things.

[00:30:45]Uh again, you can navigate to the uh security configuration. Let's say you split your security configuration into multiple uh components, then you can click and then navigate to where this security is configured. That's another uh cool feature.

[00:31:02]So, this is one new feature that we added to Spring Debugger plugin. And uh another interesting feature that is added in this release is uh Flyway DB migrations.

[00:31:14]So, as you can see, I have started the application. And uh here I already have two Flyway migration scripts, and you can see these little green check marks, which represents these two migrations are already applied in the database.

[00:31:29]Let's imagine I want to invoke uh I want to create another uh migration. So, I already have one migration one, and I move it to migrations folder. Now, you can see this doesn't have that green check, uh which means it is not yet applied. Now, one way is usually you restart the application, and then uh it will be applied. And we have uh added a uh specific option to invoke that Flyway migrate, so that you don't have to restart and just to apply the migrations. You can simply invoke this, and here you can see in the log, it already applied, and also you can see here the green check mark is applied to this third migration as well. So, if you ever want to uh apply the migrations, you don't have to actually restart the application and all that, you can simply use this functionality to just uh do the Flyway migrate. And in addition to that, you also have options to specify what is the DB connection, and uh where all these migration paths you want to take, because this is a Spring Boot application and the default one is inside the class path DB migration, but if you store in multiple locations, you can pass all that information as well.

[00:32:47]So, this comes very handy, but another very interesting feature is let's say we are adding one more Flyway migration and let's imagine we want to apply this. So, let's go ahead and uh >> Just one more migration.

[00:33:05]>> Just one more migration.

[00:33:07]So, I'm trying to apply this. As you can see, this got failed and here you can see the red icon which says this migration is failed to apply. And here we have just three insert statements which is easy to find, but imagine you have a hundred or two hundred lines of migration and your console simply says that this migration failed. It doesn't say where it got failed and which specific statement it is getting error and all that. Now, IntelliJ shows you exactly which statement got failed with a error icon. So, it is very easy to see, okay, this migration got failed and you can immediately navigate to which location and it also provide you some information that which kind of a error you are getting. So, if you ever find yourself debugging this Flyway migration errors, you would definitely appreciate this help.

[00:34:06]So, uh these are the two features and then one of the complaints, I mean, there are many issues regarding hey, I am using configuration properties in my Spring Boot application and I often navigate between properties file and then where it is being used. So, I want to have some smooth navigation support.

[00:34:27]And earlier there were many bugs around it and in this release many of those bugs were fixed and also the navigation support is greatly improved. Uh let's take a look at what kind of improvements we have. So, here if I go to uh application.properties, I have all the application specific properties here and I have a configuration properties bean that are uh bind all these values into. Now, if I click on this green uh spring icon, I can see where this property is being used. Like, as you can see here, I have it in uh default application properties file and I have it in uh local uh profile specific properties and then I'm also uh using uh this in a specific test overriding some uh default value with something else. So, like that you can navigate between the properties and where it is being used. So, it gives you uh imagine if you are working on a very big Spring Boot application where the properties are used all over the place and sometimes using uh command shift and then trying to find matching the uh keys uh not very pleasant. So, here I would say this is really nice to navigate and then find where it is being used. And not only the uh functionality internally uh in the implementation itself, uh there is a uh good improvement of performance. As you can see in this graph, uh this is how it used to be in the uh internally, how much time it used to take the parts, all that and then map into the elements and all that. Now, in this release, the internal implementation is improved uh quite a bit and you can see the uh time it take and uh is drastically reduced and it is much more faster now.

[00:36:17]>> Very, very nice. Thank you, Siva.

[00:36:20]Which brings us back to well, build tools. Gradle and Maven. Marit, what what do we have?

[00:36:28]>> We have some pretty cool stuff, actually.

[00:36:31]Uh so, if you're working with Gradle and you're using the the Kotlin build files, then you know that it's a Kotlin file, which means that it will actually have a code completion for Kotlin, which isn't necessarily very useful for your build script. Um so, what we've done is we've cleaned that up for at least the dependencies block. Uh because that's the part of the build script that you're probably most often editing by adding dependencies or updating dependencies.

[00:37:03]So, now if you have or have completion inside the dependencies block, it will show you only the relevant things for your dependencies block. So, like the scopes like implementations, so we can add dependencies there.

[00:37:20]Uh it also supports the version catalog, so we can use stuff from our version if we want to add dependencies.

[00:37:30]And then we can navigate to the the version catalog as well.

[00:37:35]Um but not only that, it also has we have dependency completion. So, that means that if we want to add new dependencies, um let's say H2 database, it will actually find those dependencies. And as you can see here, many of them have a little cute cloud icon, meaning they are fetched from our server.

[00:38:01]So, it's going to actually look for those dependencies. And then we have one that has the home icon, which is actually coming from my local cache. Uh so, before it would only find stuff from your local cache, now we have a server where it will find stuff uh that is on Maven Central, essentially. Um so, that you can import the latest version of of your dependency Uh and you can actually invoke search on a part of that and then it will give you everything with the same coordinates. So you could look for newer versions or different versions if you want.

[00:38:36]But not only that, we don't even have to use our implementation scope etc. We can also look for a dependency right away like JUnit or JUnit Jupiter and it will add the right scope and the latest version.

[00:38:54]So if you want to add JUnit, it will add JUnit 6.1 with the right test implementation scope.

[00:39:03]And that part obviously for the Maven users also works in Maven. So in Maven previously only we had only the the completion for the local cash. But now if we add let's look for the same H2 um database, you see that that shows up and with the if I select that also it will auto complete that to dependency. In this case it's a duplicate because I already have the H2 database in this palm but just to show that it works there as well.

[00:39:36]So I think that that's really cool to get the completion and make it easier to um yeah, get the latest dependency so auto complete the latest version of the dependency.

[00:39:48]>> that I don't have to think about the syntax how to declare the dependency.

[00:39:52]>> Especially for Gradle, you know.

[00:39:54]>> know the name of the dependency.

[00:39:56]>> So one thing to know is that it will actually search the server when you have typed enough enough characters for it to to search for something useful and then if you continue typing it will search from the list that it's already fetched.

[00:40:14]And if you want to like force another fetch as it says here in the hint press for Mac it's control space that will force another completion and that will fetch then stuff from the from the server again. So if you're not finding the thing that you're looking for because it already fetched based on on fewer characters force another fetch and and see if you can find find what you're looking for.

[00:40:39]Yeah, so I think that that's super useful.

[00:40:43]For making it easier to to work with build scripts.

[00:40:47]But wait, there's more.

[00:40:51]Before you interrupt me Marco.

[00:40:53]So as you might also know Gradle might have some breaking changes in every version and currently if you're then importing a project with broken build scripts or you're upgrading your Gradle and now your build script is broken or maybe your agent wrote something based on older Gradle versions and now your build script is broken previously IntelliJ cannot sync your project so also it can't find the load the projects and we are collaborating with Gradle.

[00:41:28]Which is cool sometimes the Gradle folks show up at the office so you know, so we can collaborate on stuff.

[00:41:35]So from the upcoming Gradle 9.7 and onwards we will make sure that you can actually sync the project also when the build script is broken. So to show that let me update the Gradle version.

[00:41:53]And because this is a project with three different projects have to do that three times.

[00:41:58]Quickly so we'll update to the custom Gradle build that we have just to to demo that that this is going to work and then when we sync the Gradle project we can see that it's going.

[00:42:14]I love this part about demos when you have to wait for stuff to happen and and fill the time.

[00:42:20]But as you can >> You're doing great.

[00:42:23]>> Any stories you want to share with us in the meantime? So as you can see now we get like the green the check marks. I love green check marks left over from my days as a test engineer.

[00:42:37]So that means that it did actually sync the project and now we it will that means that we can also see the project in the Gradle tool window. We can get some syntax highlighting in the build files already. Another thing that we have is you can now No, I don't want to import it. I want to jump down to the code so we can navigate from the build script to the Gradle code and that will actually navigate to the right version of of Gradle so that you can see what has changed in the API and that you can fill your fix your build script.

[00:43:13]And then another thing that we're going to work on is for Gradle 10 and upcoming of course there there might be breaking changes. So we're going to work on having some quick fixes to make it easier to then fix your your build script and and get everything working. So either when you're upgrading to a newer Gradle version or you know if your agent generates a script that doesn't work, that should be easier to work with.

[00:43:40]>> Currently what we see on your screen is that it partially imported and you can see the project structure even though the script is not compatible with the new version of >> With the current version. So it will at least IntelliJ is able to somewhat sync the project and understand the project.

[00:43:57]So we can see the this is this project has has three projects in there so we can see them in the Gradle tool window. We can also see uh the tasks and things that we couldn't see pretty easily.

[00:44:08]>> errors there are intended. It's not that it's broken.

[00:44:12]>> not It's not broken. It's a different state of broken. The script is still broken, but at least now it's showing us where it's broken so that we can more easily fix it.

[00:44:20]>> of broken.

[00:44:21]>> Different shades of broken like a different set of broken.

[00:44:23]>> So it's it's not as broken as before.

[00:44:26]It's still broken, but it should be easier to you know now you can at least sync the project and find out what's broken so that you can fix it and we'll add quick fixes to um to help that. And one thing that I forgot about the um dependency completion uh just to wrap that up uh that's the one I'm most excited about. Um because we now have this server with uh the latest versions and everything so that we can offer you this completion. Uh we're also looking at what what else we can do with that information such as warn you when there is a new version so that you can update.

[00:45:00]We already have the package checker that will tell you if your dependency has a known vulnerability. So that we already have, but of course there's more that we can do with this dependency information on the server. Uh like maybe also expose it to agents so that they know what the latest version is and wouldn't it be nice if you don't have to fight your agent on what the latest version of a particular dependency is so that doesn't helpfully upgrade to the previous version.

[00:45:25]So Yeah, lots of cool stuff.

[00:45:27]>> Thanks, Bart. By the way, as always let us know if your team maybe not Team Gradle or maybe even Team Bazel uh down below in the comments.

[00:45:34]>> As we see.

[00:45:36]>> SP T also. What about ANT?

[00:45:39]>> Sorry, Anton. What year is it?

[00:45:41]>> If you're actually using ANT, let us know down in the comments below. Right then, last but not least um Docker Anton.

[00:45:47]>> Docker um this is the kind of updates I like the most when we add a single small little feature and it suddenly makes a difference.

[00:45:56]Uh in the previous release uh if you haven't seen that, you should. We had an update for Kubernetes and the inlay hints in Kubernetes descriptors and we are continuing the team is continuing to improve on the same kind of features but now for Docker.

[00:46:14]And one first little feature that I want to show is when you want to start deploying something to the Dockerfile and you are not fancy using agents to generate them maybe you want to craft them. Um let me demonstrate that so Docker Compose >> Handcrafted artisanal Dockerfile sometimes.

[00:46:34]>> Yes, handcrafted.

[00:46:36]Uh files. So I let's say I I create a new one and it's empty and there's just services uh label like the the block is there but nothing inside. Uh there is a helpful little hint basically helping you to overcome this blank or white canvas uh block uh what what to type and if you click that uh it brings up a list of uh a fixed list of templates that you can configure in your Docker Compose file for different databases uh accused basically different different resources or you can simply start typing if you know that uh you are going to use MySQL uh you start typing MySQL it's going to it's going to populate that template for you immediately and then obviously you can edit that further. Uh that's uh just a simple >> But super handy.

[00:47:36]>> very straightforward nothing super smart about it about this one.

[00:47:42]Uh so there is no like smart logic behind or anything.

[00:47:46]It's just a left the plate kind of >> Uh but but but completing some YAML is always a good idea. I always probably all thought a YAML file on some white space that wasn't there or should have been there.

[00:47:58]>> So, sometimes just this kind of small things make a difference.

[00:48:02]But, uh the other thing that I'm even more excited about is uh when you start integrating different things together.

[00:48:11]Uh so, the runtime information uh with what you see in the editor and so on.

[00:48:17]This is exactly what we did uh in the previous update for Kubernetes, and now we did this same thing for uh Docker Compose. So, when we look at the uh Docker Compose file with a few services uh that I have already started, I can see some inlay hints that I can hover over and uh I can see uh that the service is running. So, there's a running label, and if I click that one, it actually navigates to the services window um to that pod or like the the the container. Uh and showing it's healthy, I can inspect the logs, and I can navigate back. Uh so, for instance, if I if I close this file in the editor, I'm like I I worked for a for a while, I maybe inspected some code, I navigated through my project, and I and I'm looking at the services window, and I want uh to figure out where the web server is uh declared, I can jump to source, and I jump to the definition of that web service. Uh obviously, the running label is not the only possible one. Your your uh container might not start, something is broken. There I have an emulation of that uh failure. So, the the service uh starts with an error, and uh there is a failed uh label rendered next to it. So, if I click that one, I will see in the log that okay, there are some errors and I it it just helps me to diagnose what what's going on.

[00:49:58]Uh and even more useful stuff, my application is currently running, the service I deployed with Docker Compose. And when we can detect that there the ports are forwarded somehow, let's say I have a web application obviously with a web UI, and I want to access it, then there is a little button rendered next to the port forwarding uh block to open it in a browser. If I click that one, takes me to the UI of my application that is running.

[00:50:30]And we can do the same for the databases.

[00:50:33]So, there is a Postgres database that is running inside the container and port forwarding is done. And if I click that button, then it takes me to the database source.

[00:50:47]Obviously, it's currently uh preconfigured for me already cuz I did that before, but if I didn't have it configured, then it would pop up with the configuration screen populated with all the connection details, password, user, database, and so on. And then I could configure the data source for my application right here.

[00:51:07]Uh all automatically. So, just a few little things added, and it already makes the things better.

[00:51:15]>> Yeah. Very powerful.

[00:51:17]Right, and that's already a wrap. Uh you've now seen all the new well highlighted features in IntelliJ IDEA 2026.2.

[00:51:25]Uh as Marat earlier said, wait, there's more. You'll find the entire list of all the new features in our blog post.

[00:51:32]Um but for now, please download the new version, and as we've told you before, we crave your feedback. Let us know what you think.

[00:51:39]Try out log points, try out all the other different things that you just saw, and let us know any good or bad things about them.

[00:51:45]Um thank you all for present uh presenting today. Thank you all for watching out there and uh I'll see we'll all see you soon in the next What's New stream.

[00:51:55]Thank you very much. Bye-bye.

[00:51:57]>> Bye.

[00:51:58]>> Bye.