[Music] [Music] Heat. Heat. [Music] [Music] [Applause] Heat. Heat. All right. All right. All right folks. Hi and welcome to Cotlin [Applause] Conference. So happy to see you all here. My name is Kier and I'm a Scotland developer. Well, I'm also a JetBrain CEO, but who cares about that here and today, right? At my heart, I'm still engineer, someone who really loves code. A few weeks ago, I duck our commit history and found the first piece I ever wrote in Cotlin at Jet Brains. Just look at that. Isn't it funny? As if somebody tries to write C# code right inside intellig idea. But that's for a reason because this is one of the first files for Ryder, our net ID. So you can understand the legacy here. The interesting thing about this piece of code is that it was written in January 2015, long before the official Cotlin release. Why? If you haven't heard, Jet Brains is a company with a crazy engineeringdriven culture where engineers, developers, us trying to adopt all these new cool things as fast as possible, new languages, new frameworks, new tools. And back then in 2015, Cotlin promised us great readability, flexibility, safety, and interrupt with Java. And as we know all of these things paid off really well. Now one of the coolest thing things I was so passionate and I am so passionate about Cotlin is that our test engineers and engineers could write tests like this in a natural language. But this is 100% legit Cotlin code. Thanks to all these fancy features like lambda with receivers, global static methods, you can basically write it in English. Isn't it cool? And this was real in 2015. Now 10 years later, Cotlin is everywhere. Just think about it. Roughly one out of 10 developers worldwide is programming in Cotlin and its adoption continues to grow. We built cotlin for developers but also by developers by us. This is one of the greatest things we built at Jet Brains. And honestly, we couldn't do this without you. Cotlin thrives because you, the community, built libraries, thousands of libraries. Cotlin evolves because you provide your feedback. You embrace curiosity. You exchange ideas. Cotlin grows because you spread it out across the world. So, Cotlin is as much our language as it is yours, my dear Cotlin community. Thank you. Thank you. Now in 2025, building such an impactful thing as Scotland indeed puts us on a crossroads of what's happening in the industry. And oh my gosh, so many things are happening right now. I think you're familiar with all these buzzwords like new revolutionary AI framework tool, some bold statement of some CEO and all this stuff, right? Yeah, you got the point. So, and some of the things go viral and fade away even before we actually try it. So, I don't know. Yeah, you got to have 48 hours per day to stay on track. But the fair question here is where is the place of Jet Brains and our beloved Cotlin in this mess? And since we are as I said already very much engineering organization honestly we've never been and we are not hype chasers. So we are not building AI just for the sake of AI. Instead we get only those things only those promising real tangible things which really increase what matters for us for jet brains. They increase productivity and bring joy. And today we're confident that yes, AI can really improve our real engineering lives. So we put our long-term AI bets on three main areas. First and foremost, we just released Juni, our AI agent. We actually released it in April and we already got enormous amount of very positive feedback from thousands of developers, real developers. And again, we've not just released yet another AI agent. Uh we were not targeting it for wipe coding of pet projects or some you know synthetic benchmarks. We created Juni from the day one to be capable of solving real industrial professional tasks and it does so and it does it really well. It it's really magical. Please try it if you haven't and of course it works perfectly for Cotlin. Now we are working to combine two very powerful technologies Juni and Cotlin multiplatform. So you can build you can use their power to build cotton apps on all the platforms. Secondly, we constantly integrate the best from the AI industry into our ids, our tools, whether this is code completion or unit test generation or commit message generation, other fancy features. But we battle test these features against you real developers feedback. And we introduce the free tier for all of these AI features for all of our IDEs. So they're now available for much wider developer audience. And of course we are working really hard on our beloved Cotlin to be the best programming language language in the age of AI age where well maybe majority or at least a lot of code will be generated by AI right so we create our own models we built our own models which produce really high quality cotlin code we integrate these models into our tools we open source this model for community. We partner with tool with leading AI companies such as Entropic, OpenAI, Amazon, Google. So the industrial LLMs also produce higher quality and up-to-date Cotlin code. Cotlin's readability, flexibility, and safety makes it a perfect target for AI generation. Right? So, I'm really happy that all those design choices we we made back then and I was so passionate about in my first example, they're even more important than ever. So, let's explore all these new innovations, all these new technologies. Let's do what we developers love to do, deep dives here at Cotlin Conf and let's have some fun. And to kick things off, please welcome Mike, the lead language designer for [Applause] [Music] Cotlin. Good morning everyone. Cotlin continues evolving and there's tons to talk about regarding CL evolution. And first we start with the release of Cotlin 2.2 2 which is available as release candidate 2.2 2 stabilized quite a few language features that we've already talked about before such as guard conditions, multi-doll string interpolation and no local breaking continue. It also brings context parameters to beta stability. K2 mode also becomes the default intellig idea 2025 which means that now your ID uses part of the much faster K2 compiler. And to get an understanding of how much faster the K2 compiler is, I want to show you two key results that I'm particularly excited about. First, let's look at the compilation time for the intellig repo, which includes nearly all our projects at Jet Brains, covering our 12 million lines of code in Cotlin. And you can clearly see when we turn on Q2 mode for the repo, compilation time went down by about 40%. That's huge. Another result comes from Google. For them, build times for Android Studio went down by about 30%. Not on CSI benchmarks, but on their real end to end builds. Build speed was one of the motivations for building the K2 compiler. So, it's great seeing these improvements. But we had another key goal in mind, too, and that's the ability to introduce language features at a steady pace with quality in mind. because we want to make cotlin continuously more ergonomic, improve its type safety and make the core feedback loop faster. And there's a number of coming features that I want to share with you today. And so let's explore them. The first one is about position destructuring and data classes. Currently, if you have a data class like talk with the properties title and speaker name, cotton allows you to dstructure it into its primary constructor properties like this. But it's relatively easy to make mistakes here. Here we assigned the property title to the variable name and the property speaker name to the variable title. That's very likely not what we want. And the main issue is that you can't really spot this mistake without checking the declaration of the talk data class. To mitigate this problem, we'll be introducing a new feature called namebased destructuring. With name based destruction, you move the val keywords into the parenthesis and that indicates that each variable binds with the same property of the same name. With this approach, the compiler enforces that the names of our variables are the same as the names of our properties. And that prevents our mistake because now the compiler emits an error that such a name and property doesn't exist. Changing the name to speaker name fixes the mistakes and makes the compiler happy. The name based destruction feature involves a few migration steps and to get it right we'll be rolling it out gradually and presenting as experimental in cotlin 2.4. Before moving on to the next feature I'd like to briefly highlight how our nullability system tracks with error handling. Imagine we have a function fetch user that returns a user object or null if it fails. Also, we have a function charge that charges the user some amount of money and return a transaction ID or null if there is an issue. Next, how can we use these functions? Well, we can fetch a user and attempt to charge them, but the compiler prevents a direct call to the function charge since there might be a fetching error. Good. It actually forces us to use safe call or check for null. So let's use a safe call. Now we can safely charge the user some amount of money and report an error if the operation fails. The code is simple and elegant. It's almost perfect. But since we are using null for different types of errors, it's hard to tell where the error happened when fetching the user or processing the transaction. And there are several ways to handle this, but they can be quite verbose and not very flexible. And we believe we can do better. So let's look at our new feature that we call reach errors. Because rich errors are designed to support this common error handling pattern at the language level. So we start with the same functions, but now they return not a nullable type, but their main type or an error. For instance, fetch user now returns user or fetching error. And the function charge now returns transaction ID or transaction error. Where fetching error and transaction error are regular declarations marked with the error modifier. Next, what happens with our code? Same as before, the compiler prohibits a direct call to the function charge since there might be an error. Good. And also same as before we can use our safe call operator but this time instead of checking for null we get full information about the potential errors. Reach errors generalize the concept of nulls as errors and our plan to introduce a first preview of this feature in cotlin 2.4. And while we are here let's take another look at this piece of code. Here we charge a user a large sum of money and reported that the transaction completed. However, we know that the operation might fail. That's right there in the function signature. And without proper error handling, we could leave our user in uncomfortable situation, unsure whether the money was actually charged or not. And I don't know about you, but I've definitely been in those situations. And this is where our next feature comes in. Must use return values. The feature prompts us with a warning if the return value is not used and simply ignored because most functions that return a value do so for a reason. Ignoring the return values is almost always a mistake or code smell. And actually as well as letting errors slip by. So if you thought the compiler will miss a branch, that's not the case. The compiler will ask you to put the missing branch or to write an else. Our plan is to make the must use return values feature the default behavior everywhere. And to get there, we'll be rolling it out gradually. We start with our libraries. And in cotton 2.3, the standard library and cotton x libraries are marked with special annotations that trigger the unusual value checker when you enable the opt-in. And from there we bring it to more libraries and ultimately enable it by default for all the application code. The next update isn't about language features. So we can take a moment to relax. Instead it focuses on the compiler API. Cotlin compiler plugins can unlock entirely new programming paradigms or simply improve existing ones like our noark and all open plugins help integrate with spring and the compost compiler plug-in enables declarative VR development. We truly value this and more importantly see more and more new compiler plugins emerging. We also acknowledge that unstable compile API slows development and increases maintenance cost as almost every cotlin update requires changes. However, with the K2 compiler, we are gaining confidence in the stability of the compiler internals, something that had long been an open question for us. And so, finally, we are experimenting with a more stable format for the front-end compiler API to make it easier to add custom checks and code generation extensions. And there's one compiler plugin I'd specifically like to highlight which is the power short plugin. As usual, let me start with a problem statement. Imagine we have a class mascot that has properties language and name and a simple property that holds cotlin mascot information with a small mistake. And I want to write a test which might look like this. Just a short equals checking that mascot.name is equals to kodi. So what happens when I run it? Well, because I used the wrong name, I get an exception. But the first thing I see is that I got the order of my arguments wrong. So, expected and actual are backwards. But also, this error message isn't that much useful. So, I'll probably spend some time debugging my test. And here's how it approaches with the power short plugin where I can write what's probably the most natural code ever. Just checking a short without any special specialized assort functions with regular equality. Now when I run my test and it fails again, I get all the specific values that I use in my assort expression. Power assort will become part of the language. And as this first step, we've moved it to the cotlin monor repo and simplified its configuration. But here I'd like to pass my word to sea cotlin project lead who will tell you more about [Applause] [Music] this. Thank you Michael great. The thing I really like about power assert is that it feels like it's a natural part of cing. It doesn't force you to learn any new features or technologies. It does not introduce any new concepts. It's just here and immediately it makes your development experience much more enjoyable and friendly. But what if you want to leverage the cotlin ecosystem at its fullest to use cotlin firstization framework to preserve the backwards compatibility of the code you're writing to have beautiful documentation with docker or to ensure the quality of your work with cotlin cover for that you'll have to configure and enable all these capabilities explicitly in your build system of choice and of course you have to do it along with cotling but then you might want to tweak the outcome to have let's say more granular API validation to cross reference external documentation or to customize your coverage reports suddenly in all together it doesn't look that joyful simple or natural to codling it's pretty clunky it's not recognizable and all these configuration blocks they slightly differ from each other for sure we can do better and moreover the ecosystem is don't know about plugins or configurations. It's about everything, libraries, language, and how everything is connected. So, if we'll just add libraries to this picture, we'll get something like this. Something disconnected. Every tool has its own unique name or a different naming scheme. And versioning policies are completely different and awkward. Every tool and library has its own. And as a result, for example, it's really hard to figure whether cotlin daytime here is compatible with cotlin and whether they both are compatible with cotlin 2.2. Probably you'll have to look it up somewhere. But we are an ecosystem. We can evolve and we all know that all these tools are essential part of cotling core part of cotling. So there might be only can be only a single version the cotlin version. In fact we don't even need any names. We can get rid of them. It's all just cotling. Cotling documentation, cotling coverage, cotling validation, cotling power assert. All built in into all build system packages available out of the box. Consistent, convenient and familiar. The same principle we can apply to libraries and instead of having a variety of coordinates and version just have the cotlin ecosystem with everything discoverable with a few keystrokes and automatic versions alignment. So you don't have to care about versions coordinates and whether they compatible with each other. You have just the cotlin ecosystem just single cotlin version and everything what is available in the current codling edition. This is going to be a multi-year effort spanning across multiple releases involving every part of cotlin language libraries tooling everything to provide you this seamless cotlin experience as good as it gets and some parts of it already experimentally available starting from 2.2 and others will be in upcoming releases so you can have better and better cotlin developer experience. So we started with quite a setup libraries coordinates versions and ended up with a simpler and more elegant way to start a coding project. But can we do better? What if we didn't have to configure anything at all? What if we had something natural to cotling? Something built with a cotling support in mind from day one. Something something like this. Something as simple as one line configuration file without anything extra. That's the power of Amper. Our experimental Cotlin and GVM build tool like Cotling. AMP is toolable developer friendly with a clear configuration path ID support and error reporting. And of course it supports all the codling capabilities whether you're writing a multiplatform application a backend implementation with spring aa client or a common line tool and as my personal favorite amp is completely self-contained build system with a beautiful command line interface that can be used in any environment and with any kind of tooling. Currently it is experimental and has brought to alpha with the goal to be the cotlin and the jvm build system. Fast, pluggable, toolable. So check it out, try it, enjoy it, and most important have fun with it. [Applause] So EMA joins a variety of build tools in our ecosystem and for a build in order for a build system to support cotlin it has to account all the cotling capabilities incremental compilation language configuration compiler plugins demons and that's a lot of work that's a lot of repetitive work because each build system has to do that so instead we're introducing Build tools API fast universal uh unified API layer that abstracts away cotlin for any build system and provides the same experience for any cotlin user the best experience. How does it help though? Now for build tool to integrate with cotling it is enough to support a single build tools API entry component and it will take care of the rest providing as good experience cotling experience as it gets for all cotlin users of your build system. Builders API is experimental starting from cotlin 2.2 and we we are already using it in our gradal and amp integrations with more to come. So we are strengthening our ecosystem in every front language libraries toolings build tooling build systems but the last the last but not the least goes cotton found I should mention coten foundation the foundation that helps us to achieve our mission of cotlin everywhere this year it's getting stronger as two new members join cotlin foundation block inc and matter as silver and gold members With the help of all these members for the last two years we've been recognizing and rewarding the most outstanding contributions to the cotlin ecosystem with the help of cotlin foundation grants program. So let's applaud to year 2024 foundation grant winners these amazing libraries and of course this year is no exception. So view if you're an author of open source library that enables a unique use case covers a well- definfined domain or operates in an impactful area such as code and multiplatform or tooling around AI or large language models we'd love you to apply and here I'd like to pass my word to sweater to talk about enticing world of AI [Music] [Applause] [Music] AI is changing what's possible in software both for users and developers. Companies now see the value of what they can build from chatbos to code generation and new ways to interact with your software. EA capabilities are now becoming expected in enterprise applications and you can develop all of this in cotlin. When you integrate a models into your workflow, you use a typical AA tool set that helps you to solve standard problems. It includes concepts like chart memory, rag tools or agents. Together with the community, we've built a bunch of libraries to provide you with this essential a tool set. They work on different levels depending on the complexity of your use case from lowlevel model SDKs up to agents. You can work directly with an open AA provider with an model API provider like open AI. They promise to release their cotton SDK soon. But so far you can use their Java SDK. By the way, it turns out to be written in cotlin. If the clot model works best for your use case, you can use an official anthropic Java SDK. By the way, it's also in [Applause] cotlin. But usually you don't need this low-level access. You use a high level library that allows you to easily switch between different model providers and come with a whole bunch of extra features from this AI tool set. One of these highle libraries is spring AI. It contains some cotlin specific functionality like the ability to register a cotlin function directly as an AI tool. Like for example here we define the get talks function and register it as a bin. And then you can prompt the model which talks at coding con 2025 are related to AI. And then this function because it returns the list of the tools the model can use it and come back with a whole bunch of uh the talks and if you want those covering spring a specifically you can reward your prompt and check the sessions by Rod and Sebastian which will go right after the keynote. You can take your AI integration up a notch by adding an agentic layer. AI agents are now becoming the way to build advanced AI applications. That's because to get something useful from an LLM with a real world impact, you need to give the model access to the tools and provide feedback back to the model. And that's essentially what agents are all about. A tool is a function, however complicated, a regular piece of software. Anthropic last year released a protocol to standardize an interaction between agent and tools. We released the cotling support for that. That means you pro you can provide your agents with the tools implemented in cotling. For example, as a conference API provider, you can define an MCP server with the get talks tool. Then it becomes easy for third party agents to use it. Cotlin is used in production for many a power systems already. And one story I'm pleased to highlight is Deutsch Telecom using Cotlin to build their LLM power chatbot, one of the biggest chatbots in Europe. Check out Patrick's talk to learn more about that and about arc a framework that was born out of their experience. Another company pretty large with a lot of AI functionality written in cotlin already in production is actually Jet Brains. And to speed up our own developers who are working on AI features all over the place, we've built a framework that we want to share with you. And today we are sourcing Koug a framework for developing a agents in cotlin. [Applause] Each comes with a bunch of predefined workflows and patterns which you can use directly or combine. Here we define a simple banking assistant agent working with GPT for all. You give it your open API key provide with banking tools set up a tracing feature and that's all in one function call. You can then run it with a user request. If your agent logic becomes complicated, it's typically expressed via graph representing the actions, nodes, and conditions, edges to go from one action to the next one. In this example, we use LLM to classify the user request and then depending on the result, we route it to either a sub agent responsible for transferring money or a sub agent responsible for analyzing transactions. If LLM was not able to perform classification, you can decide to ask the user to clarify what exactly they want and then ask LLM to classify the updated request again. So your graph can contain backwards ages and cycles. And this way you can express rather advanced logic in a cotlin DSL and then you can share it with your ML colleagues who can understand it even without knowing cotlin. What's more with automatic tracing of each of each node and age you can observe what your agent is doing and reason about its behavior. This framework is based on a real experience of our jet brace engineers and we hope you'll find also it useful. To sum it up, cotlin is a great fit for developing a power apps including sophisticated agents. Let's now look at it from a different perspective. How AI can help you develop cotton apps be it server side mobile multiplatform whatever whatever you want at Jet Brains we build a to boost your productivity to make your work more enjoyable it handles the boring stuff so you can stay focused and in control of your code you'll find a features throughout J brain CDs helping out exactly where you need them you can chat your with your code base, ask questions about your project and it'll gather the relevant context to provide you with accurate answers. The code completion is powered by Malum, a large language model from Jet Brains. Malum focuses only on coding and because of that it's really good at it. It's designed to be really fast to work in production or large code bases and to make suggestions that actually make sense for a project. Moreover, there is a version of Malum fine-tuned specifically for Cotlin and today we're open sourcing it to make it available for the broader develop and research [Applause] community. A changes how we develop software. Do we write code or does AI write code for us? Recently we released Juny, a coding agent from Jet Brains. Juny can perform pretty complicated tasks. For example, you can ask it to implement a feature that shows a random talk in the causing conf. Then it creates a detailed plan of what needs to be done and starts implementing item by item. Juni is very good at following the patterns already present in your codebase while keeping you in charge of architectural choices and project vision. You can check what June is doing exactly by following the changes it made to the project at each step. It can compile code and if something doesn't work, it can fix the problem by itself. It can also run tests to make sure they pass. Look, now the dice icon appeared at the top. We can click on it and indeed it shows us a random talk and it was all implemented by Juny. I must say the future is already here. Juny is much more than a productivity boost. It's a new way to write code. You might say, I like Juny. I tried it and liked it, but it's not that fast. The screencasts are clearly sped up. Yes, coding agents take their time to think. So, we've been experimenting with running Juny in the cloud, letting it for example fix GitHub issues and contribute to your project. How does that work? You have an open issue on GitHub. You tag Juny and it's ready to help. It starts solving your task. When it's ready, it creates a pull request with a fix which you can comment on asking for further improvements just like with a regular contributor. When you are satisfied with the result, you can merge Juni's pull request into your project. In this way, you can even ask it to work on different issues in parallel. We are going to open the EIP program for Junior and GitHub soon. Stay tuned. [Applause] Junior works for any types of applications, serverside, Android, and we are working to make it especially good for coffee multiplatform. And now I want to invite Martin and Kate to talk more about coffee multiplatform. [Music] Thank you, SA. We would love to talk about Cotlin multiplatform. So, Kate, should we start by explaining what KMP is? Actually, no, cuz I don't think it needs an introduction anymore. It's a stable, mature technology and it's flexible enough to fit any kind of project. Whether you are starting something new or scaling a large codebase, working alone or with a huge team of developers, building apps with shared or fully native UIs. So, let us break down what's new and exciting across the system. We'll start our updates with the IDE which is at the heart of the development experience. We are now providing KMP support with a brand new plug-in which you can use in your favorite IDE whether that's Intellig Idea or Android Studio. With the plug-in installed, you can create new multiplatform projects within the IDE using the KMP wizard. Then once you have a project open, pre-flight checks will ensure that your environment is set up correctly and help you fix it if it isn't. You can also work seamlessly with both Swift and Cotlin in the same project. In this example, we have a Swift UI view that calls into a Cotlin class and we can both navigate and debug code across language foundaries. And of course, you also get support for compos multiplatform such as previews which are now available for your components even in common code. We're really excit We're really excited for you to get your hands on the new plug-in and you can get it today from the marketplace in Intellig Idea or Android Studio. Next up, we have some updates for Swift export. Swift export is a tool that generates in diameatic layer of swift code for your cotlin APIs which makes calling into cotlin from swift much nicer. To implement swift expert we need to map every cotlin language feature into swift APIs from the ground up. The team has made a lot of progress since last year and we now have most core language features covered. This all will be included in the first experimental version of Swift Expert which is coming in Cotlin 2 to20. We will then continue adding more features such as highly requested ones like corines and flows coming soon. And now let's talk compose. Compose multiplatform is the UI framework for KMP allowing you to share UI code between iOS, Android, desktop and web applications. It already powers the experiences of millions of users and there are more and more companies who are choosing it every day. And we know that many of you have been waiting for one specific thing. [Music] [Applause] [Music] [Music] Thank you. Yes, iOS is now the third stable target for compos multiplatform joining Android and desktop. This means you can confidently use composer multiplatform in production and build beautiful crossplatform apps with a fully shared cotling codebase. The beta release for iOS was already 90% there to being production ready. But since then, we've completed the other 90% required before we could be proud to call it stable. Let's see what that means. First and foremost, a stable release comes with stable APIs and strict compatibility guarantees. So you can build your projects on compost multiplatform without having to worry about breaking changes in new releases. Compose for iOS includes resource handling, navigation, interop with native use and firstass accessibility support. So you have everything you need to build beautiful featurerich apps. We also know how important it is to deliver an experience to iOS users that feels truly native. With compose multiplatform, your apps will have scrolling behavior that's indistinguishable from native text editing with iOS native selection and right to left support. Support for drag and drop as well as variable fonts and behavior that respects user preferences like contrast and font size. And yes, you can now use swipe gestures for navigation that feel natural on iOS. Last but certainly not least, a stable release comes with great performance. Our top priority for this release was rendering performance. And we're happy to say that compulsive platform matches the frame rate of Swift UI in our scrolling benchmarks even on high refresh rate devices. Using compos on iOS has minimal overhead as it adds less than 10 10 megabytes to an app download size and we are going to optimize this even further. And finally, compose iOS apps have startup times that are comparable to native apps which means your first frame arrives just as fast. Thousands of apps have already proven that compost multiplatform is ready for iOS. And now with a stable release, we come to see the apps that you will build with Compulse Multiplatform. We know that when you're working on UI, you want to see your code changes reflected on the screen as quickly as possible. We're making this experience better than ever before with compose hot reload. Let's see how. Here's the cotling conf again running on the desktop JVM target with hot reload enabled. As we make changes to the code, tweaking paddings, colors, and sizing, hot reload recompiles the code and updates the UI in our live running application. We don't need to restart the app to see these changes and we don't lose the existing state like the current screen or the user inputs. So, as you can see, using hot reload is a simple natural experience and you can make any change in your code and hot reload will keep up. You can modify layouts, rewrite screens, or develop entirely new features all without having to restart your app. And now the best part, you can already add hot reload to your projects and enjoy blazing face iteration on your shared UI. Next, let's take a look at the web target for compos multiplatform, which is also evolving quickly. In the last year, we collaborated with browser vendors to increase performance, improved input handling on mobile devices, and added web implementations for more APIs, bringing it even closer to feature parity with our other platforms. Looking forward, the next items on our road map include interal features, which means you'll be able to embed HTML elements into your compost code on the web, as well as accessibility support. And we also have a cool new way for you to try compost on the web without having to set up or install anything. It's now part of a cotlin playground. So you can write and run compost code right in your browser. And that can be pretty much any browser as all of them have full support for web assembly now which is what powers compuls multiplatform on the web. That means your apps will work anywhere whether your users are in Firefox on desktop or in Safari on iOS. We're also making continuous improvements to the WM target for Cotlin. Rebuilding a WM app is twice as fast now after making changes thanks to the new support for incremental compilation. And you also get smaller output binaries as we reduce their size by 30% on average since Cotlin 2.0. And of course, Wom is also fast at runtime. Cotlin Wesom runs 50% faster than CotlinJS on average with Compose Multiplatform running nearly three times as fast when using web assembly. With all these improvements and more, cotton and compost for web will both move to beta later this year. But but that's still not everything we have for the web platform. On the top of our focus on cotton von, we are bringing more improvements to cottonjs. This include removing many of the existing limitations around interrop targeting the latest JavaScript standards and letting you use any modern JavaScript bundlers to speed up your compilation cycle. With that, we've seen how Cotlin multiplatform is evolving across all its platforms. Building on top of that core technology, the KMP ecosystem is also evolving rapidly. Is also evolving rapidly. You have already built thousands of multiplatform libraries and we are really thankful for all of these contributions. Last year, we promised to make it easier to publish your libraries. And to achieve that, we've added experimental support for cross compilation. This means you can now build your libraries for all targets using any operating system. For example, your CR running Linux can now produce libraries that will work on iOS without a separate Mac OS machine. In Cotlin 2220, we are enabling cross compilation by default for all multiplatform libraries. And now with all these great libraries available, it's important that you can actually find the ones you need. That's why we created kale.io, an official catalog for multiplatform libraries. You can browse the most popular libraries by category, filter search results by the required platforms and easily find the projects that fit your use case. By the way, this is all implemented in Cotlin on the back end which Seth can tell us more [Music] about. Hello everyone. Good to be back. Let's talk about cotlin on the server side because it is one of the most impactful areas that we have for cotlin and it is one where all of our favorite language really really shines. Let's start our journey with the spring framework because let's be honest it's a real powerhouse when it comes to building serverside applications on the JVM and there's really nothing quite like it. Now with cotlin you can just write spring applications right every single pattern every single feature every single approach to architecture is available in cotlin as well but of course you get to do it with all the modern conveniences like these ones that you as cotlin developers know and love. These are the things that make your code easier to read, write and of course reason about. And of course adopting Cotlin in your Spring applications that happens on your own terms with 100% Java interop. Cotlin and Java files happily coexist within the same package and you can seamlessly call from one language to the other in either direction. But of course it's all just the basics, right? There's more. The Spring team is actually building extensions that are specific for Cotlin that you can choose to build with. Cotton's co- routines in Spring feel just as natural as anywhere else that you write Cotlin. For example, you can just mark endpoint functions as suspending or you can return flows from them and they work exactly as you would expect. When using the Corin based routing DSL like I do here, I can specify my routes in a functional manner. So I can specify three routes in just five lines of code. It's natural. It's expressive. It's what we love about Cotlin. And these DSLs, they extend further as well. You can register beans programmatically or you can use access controls in Spring Security all super concisely and without ever touching any XML. It's the combination of all of these aspects, right? It's language, it's adoption on your terms, and it's these tailored extensions that make Cotlin and Spring a perfect match. Already we're seeing 27% of Spring developers use Cotlin today, including the creator of the framework, Rod Johnson, who's also here to give a talk today. And 27% it's a huge number, and it is one that we want to see growing continuously. So that's why I'm very excited to announce that Jet Brains and Spring are forming a strategic partnership. Our goal is to make the experience of working with Cotlin plus Spring truly excellent. And there's a couple of key directions that we're going into here. Full null safety efforts from the Spring team automatically provide additional safety to your Cotlin code without you having to make any kind of changes. Key learning materials are going to be provided in Cotlin. And we at Jetrains also started work on our much faster version of our reflection library cotlin x reflect. Now there's one more pairing that I want to talk to all of you about and it's one that you might not expect and that's spring and cotlin notebook. Let me just show it to you in action. I'm sure it's going to become clear. Let's return back to Caleb's IO once more which by the way is built as a spring app on the back end. Let's say I want to do an analysis of the Cotlin multiplatform ecosystem. I want to figure out what JDKs are typically targeted by most multiplatform libraries. That is information that is somewhere in the back end of this application. I just need to get to it somehow. Well, first thing I could do is I'll just start the Caleb's IO back end from IntelliJ Idea. And then once that's running, I can create a new Cotlin notebook. And what I can do then is I can attach it to the running spring process. So any code that I write in my notebook is executed in the same context as the running spring application itself. So I can now access all parts of the spring app. For example, I can grab the package repository and I can just call find all packages. It's not particularly nice to read yet. Uh so I can pull in dataf frame which is the library that we're building at Jetrains uh to work with structured data. So I can just call an extension function here. Uh and all of a sudden I have a properly formatted table like that with all the data split out into columns. So from here actually extracting the data that I'm really interested in is quite easy. I'll grab myself those packages that actually run on the JVM and I'll just dynamically add a new column. We'll call it JVM target. That one extracts the JVM target version. And we can immediately see our table be populated with these new values. So, let's see the actual data that we wanted. And let's see some distributions. I can do a little bit of quick grouping. I can do some counting. And just like that, I get the overview that I was looking for. That's a lot of Java 1.8. Uh I I'm I'm guessing, you know, backwards compatibility is good. It's good. But here's something that's of course extra neat about writing your notebooks in Cotlin, right? All the code that we wrote here, it is just cotling code. So with very very minor adjustments, I can just take that and I can turn it into a deployable rest endpoint that's part of my spring application with truly minimal changes. And beyond that, this is by the way also the perfect place to see that the dataf frame library actually provides type- safe schemas that even include things that are generated ad hoc like here the JVM target version that I just create like one line above it. That is the upcoming dataf frame compiler plugin in action. It allows you to write fully types of code even when the shape of your data changes around. The compiler plugin is part of dataf frame 1.0 which is currently available as a beta release. So as you can see cotlin notebooks are a great great playground to explore and interactively work with your cotlin code. And with this new feature, which is available as experimental, they now work with all Spring applications. And that does include those that are written in 100% Java. You can still attach, explore, and prototype regardless. If you ask me, that's pretty cool. What do you think? This feature is currently available as experimental but the rest of Cutler notebooks is stable and we want to make it as easy as possible for you to start working with it as well and do the same kind of explorations. So starting with 2025.1 uh Cotlin notebooks come as a bundled plug-in in both Ultimate and Community and in Android Studio you can simply install notebooks as from the marketplace. It's actually roughly 50% roughly half of all Cotlin developers that use it on the back end, which is honestly a number worth celebrating in itself, but you're also building a lot of cool things with it. And I think it's a good time to just see and listen to a couple of the teams that do exactly that. The tech stack we used forced us to write a lot of boilerplate code and lacked modern functional programming features which greatly reduced our ability to adapt. We faced the need for robust modern language capable of supporting a rapidly expanding feature set. We wanted technology that felt close to Java but would let us reduce technical depth, learn modern patterns and prove itself under real production load. At world our teams choose the technologies they work with and many have gravitated towards cotlin simply because they enjoy using it. Adopting cotlin has led to significantly faster feature development and a notable reduction in time spent on code reviews especially regarding nullability issues. The language has also helped us to reduce type miscast incidents in our internal tools built in cotling now allow us to launch new services in minutes instead of days. This success not only encouraged other teams to join in, but also led us to officially become a cotlin first company by 2023. We're confident that it will continue to drive improvements in development speed, code quality, and overall collaboration across the company. Our engineers are very happy with the codebase, and they're actively working to make it even better every day. We are enthusiastic about the future and the continued positive impact cotling will have on our [Applause] [Music] projects. It's always amazing to me seeing how people build with Cotlin. Next, I want to talk about another cornerstone library when it comes to networking, which is Ktor. Well, more precisely, let's talk about its two parts. Ktor client, which is our standard building block for working with HTTP APIs, and KTOR server, our lightweight framework for building network services. Now, the two are sibling libraries uh that can be used independently of each other, but the two still share a common core, and we've done a lot of polishing on that core. As part of KTOR 3, we've moved the entire IO infrastructure to Cotlin X IO. So, especially when transferring larger payloads, this change alone results in up to three times better performance, all without requiring any changes on the application code. And of course, we're evolving the framework with new features and functionality as well. We've improved work with configuration files, serverent events, with heartbeats and serialization integration, web assembly support. And we've also started work on actuator functionality that allows you to introspect your app with health checks and uh metrics all of these kind of things. Kater's adoption is actually growing very fast up 37% over the last year and we want to keep evolving the framework with the needs that you have as its users. There's one more library that I also want to talk about and that is exposed. Our library for working with SQL. Exposed allows you to express SQL queries using a fully type- safe cotlin DSL without ever really diverging from any of the core SQL concepts. But if you want, we also have an optional DAO layer that allows you to work with your data in an object-oriented approach that's even more concise. Now, the team behind Exposed has worked extremely hard these recent months and has reworked pretty much every single aspect of Exposed. They've rewritten the core of the library. New SQL features were introduced and with new onboarding materials and more love for the documentation working with exposed has really leveled up and with its new compile uh with its new IDE plug-in you can also now enjoy truly first class IDE support. But there is one key feature that probably really deserves the spotlight here and that is full R2DBC support. [Applause] Lots of R2DBC enthusiasts in the house, it seems like. Well, what does that actually mean? Well, it means that exposed can now work in a fully non-blocking fashion. It's an integration that we've built on top of Corins. So, your typical database operations like inserts, like updates. They are exposed naturally through suspending functions. Or you can have the results of your queries be returned to you as flows so that you can process results over time. Now, we're currently putting a couple of final touches on the framework, but we're rapidly approaching the point where Exposed has a fully stable API surface and will be ready for truly all production use cases. And soon, we'll be promoting Exposed to [Applause] 1.0. And now to wrap things up, please welcome Hardi. [Applause] [Music] [Applause] Thank you. Hi everyone. How are you all doing? Wow. Yeah. So, you've seen a lot today. Let's wrap it up. We'll go quickly. We've seen a lot about the Cotlin ecosystem. We have seen AI. You like it or not? We've seen AI. We have seen KMP and compose multiplatform and of course server. But then all of this is about what the language and we all love the language. Yes. Show me some love for the language. And we all love the language and we think the language is amazing. And at Jet Brains we also know that what makes a language amazing is good tooling. And we provide you with that good tooling. Intelligj idea gives you good support for cotlin. But here's the thing. We want more people to use cotlin. We want more people to love cotlin. We want everyone to enjoy what we're enjoying independently of what tool they want to use. And that is why I'm extremely excited to announce official support for Cotlin language server. Along with a VS Code extension, you can now get code completion, quick fixes, inspections, interoperability with Java, project import, and many other things. You can already download this and play with it. It's a pre-alpha. Why is it a pre-alpha? Because we don't want to call it an alpha. We'll call it an alpha when we're ready to call it an alpha sometime later this year, but please use it, break it, give us feedback, etc. And uh yes, and then make sure you continue with intellig idea. Anyway, so you will over the next two days you're going to learn a lot about what's happening with Cotlin. Enjoy it, have fun, but remember that the conference is more. Please make sure that you visit our exhibitors who are out there on the hall. If you want to try your luck and win some prizes, take the Cotlin Conf coding challenge. And then also there's a a lounge in the back if you are just bored and want to catch up on email. Then we have code labs by Google that's taking place if you want hands-on experience to really try and test the frameworks and libraries that that folks are creating. And then for those of you that are in education, whether you're university or teachers, we've created a small discussion group for you tomorrow after the code labs which is called Cotlin uh for educators. All of this information you can get from the app as always. Download it uh on any device you like and please also use it for voting for sessions. Of course, tomorrow there's the party. Sorry, tonight there's a party. Yes, tonight there's a party. There's going to be a live band. Unfortunately, there's no karaoke, so you're not going to get Eminem, but I'm open to ideas there. Closing panel traditional is happening tomorrow. We've just slightly changed it and uh you have take a scan of that and then you will ask questions on Slido or up vote for questions. Don't do it now. It's everywhere. Enjoy. Embrace the moment like like you know, enjoy. When you go to a conference, everyone's like with their phones uh not a conference, a rockstar thing kind of thing. A rock band. Anyway, talking about that, I just want to close with a few words. This is Cotling Comp 2017. Who was there? Whoa. Yeah. Whoa. Thank you. Woo. It was amazing. And uh when we decided to put on a conference, I was really really scared. Really, because I'm like, will more than 200 people show up? And 1,200 people showed up and we sold out. This is the sixth year of Cotlin Conf. And we have 2,100 people here. And I just want to say that this is possible and everything that we're doing possible is possible made by all of you. Made by the 2,100 people here, made by the 70,000 people that are a part of the Cotlin community and by the millions of developers that are using Cotlin every day and loving it. You folks give us the energy to do all of this and I'm extremely grateful to all of you. So, thank you and enjoy the conference. [Music]