Recent Posts
Archives

Posts Tagged ‘JeffreyvanGogh’

PostHeaderIcon [KotlinConf2026] KotlinConf’26 Opening Keynote: Language Evolution, Tooling, AI Agents, and Multiplatform Momentum

Lecturer

The opening keynote of KotlinConf’26 was a collaborative presentation delivered by a roster of experts from JetBrains, Google, Anthropic, and the broader Kotlin ecosystem. Primary contributors included Michail Zarečenskij, Lead Language Designer at JetBrains, who has nearly a decade of experience shaping the Kotlin compiler, IDE integration, and language specification; Vsevolod Tolstopyatov, Kotlin Core Ecosystem Lead at JetBrains, focused on libraries, APIs, concurrency, and tooling; Svetlana Isakova, Developer Advocate at JetBrains and co-author of Kotlin in Action and Atomic Kotlin; Jeffrey van Gogh, Director of Engineering for Android Developer Experience at Google and Kotlin Foundation board member; Márton Braun, Kotlin Developer Advocate at JetBrains specializing in multiplatform; Chantal Loncle, Software Developer on the Exposed team at JetBrains; Vadim Briliantov, Technical Lead and creator of the Koog framework at JetBrains; Christian Ryan, Manager of Applied AI Engineering at Anthropic in Europe; and Josh Long, Spring Developer Advocate. Supporting contributions came from Sebastian Aigner and others on the JetBrains team.

Abstract

This article examines the KotlinConf’26 opening keynote, which marked the fifteenth anniversary of the Kotlin language. The presentation surveyed the language’s foundational principles of ergonomics and safety, announced the stabilization of key features in Kotlin 2.4, introduced a unified Kotlin Toolchain, advanced the Kotlin Language Server to alpha, and detailed the mature release of Koog 1.0 as a production-ready AI agent framework. It further covered backend integrations with Ktor, Exposed, and Spring, Google’s expanding adoption of Kotlin beyond Android, and the accelerating growth of Kotlin Multiplatform and Compose Multiplatform. The keynote positioned Kotlin as a trusted foundation for modern development in an era of rising AI abstraction, emphasizing consistent tooling, enterprise readiness, and seamless multiplatform reach.

Language Foundations and the Stabilization of Kotlin 2.4

Kotlin’s design philosophy rests on two interlocking principles: ergonomics that make code pleasant to read and write, and safety mechanisms that give developers confidence in what they ship. Michail Zarečenskij opened the technical portion of the keynote by situating these principles in the contemporary context of AI-assisted development. As agents raise the level of abstraction, trust in the underlying language becomes more critical than ever. When code compiles, the compiler has already verified a substantial amount of correctness; carefully chosen defaults further reduce the cognitive load of reading, reviewing, and maintaining code—whether that code was written by a human colleague, an AI agent, or one’s own past self.

Kotlin 2.4 stabilizes two long-incubating features that exemplify this direction. Context parameters allow functions and properties to declare dependencies that are resolved from the surrounding scope rather than passed explicitly as ordinary arguments. In a typical application, an interface such as Session might expose payment settings. Checking whether a particular provider is enabled traditionally requires threading the session object through multiple layers. With context parameters, the core logic can be extracted into an extension property whose receiver is the payment provider while the session is supplied as a context parameter. The call site collapses to a simple, readable check focused on business intent rather than infrastructure wiring. The feature enables more consistent and idiomatic APIs across libraries.

Explicit backing fields address a common pattern in which a public read-only property is backed by a private mutable one. Previously this required two separate declarations representing the same state, introducing boilerplate and complicating refactoring. In Kotlin 2.4 a single property can declare an explicit backing field that is mutable internally while the property itself exposes a more restricted type. Mutable state remains safely encapsulated, the number of entities decreases, and refactoring becomes less error-prone.

Beyond these stabilizations, the language team continues to explore multi-field value classes as a safer alternative to data classes for pure data modeling. Value classes auto-generate equals, hashCode, and toString; they default to name-based destructuring rather than positional; and they lack identity, making instances interchangeable when their properties match. Looking ahead, they are expected to benefit from JVM value-type optimizations such as scalarization and heap flattening. Updates and mutable value semantics remain under active investigation, with community feedback invited at the language evolution booth.

These language-level investments ensure that students and professional developers alike receive clear, correct code by default. Ergonomics and safety form the foundation upon which the rest of the ecosystem is built.

Ecosystem Tooling: The Kotlin Toolchain, Language Server, and Standardization of Formatting

Vsevolod Tolstopyatov framed the next layer of the stack: tooling that must remain consistent even as the surrounding landscape of IDEs, build systems, and agents changes rapidly. The experimental Build Tools API announced the previous year has matured into a unifying boundary between the Kotlin compiler and any build system. It now powers every major build tool, delivering identical performance characteristics, incremental compilation, and compiler caches. Maven gains concise defaults, Buck enjoys large-scale incremental compilation, Mill adopts Kotlin with ease, and Gradle can decouple language version updates from the Gradle plugin itself. Collaboration with the open-source community is extending first-class support into official Bazel rules, enabling Kotlin in repositories that contain tens of thousands of modules.

For projects that do not require the full complexity of a separate build tool, JetBrains introduced the Kotlin Toolchain—a single cohesive entry point. Starting immediately, developers can use it for JVM and multiplatform projects to create, build, run, and test applications. Capabilities originally developed in the Amper project are being folded directly into the toolchain. Future plans include language-server integration, AI skills, native dependency management, and deep IDE support, delivering the full power of Kotlin out of the box. The toolchain is already in alpha and evolving rapidly.

Documentation consistency has become equally important once agents enter the development loop. The new Kotlin documentation model provides a machine-readable, specified, and backwards-compatible format published alongside every library. IDEs, klibs.io, and coding agents can consume it uniformly, eliminating the fragmentation of GitHub pages, official language sites, and third-party library documentation.

The Kotlin Language Server has graduated from experimental status to alpha. Backed by the full IntelliJ engine, it offers code completion, diagnostics, Maven support, formatting, and basic Android import. When a new feature appears in IntelliJ, it appears in the language server as well. An official Visual Studio Code extension is now available on the Marketplace, and agents can leverage the server for symbols, documentation, and structural understanding.

Finally, JetBrains and Meta, under the Kotlin Foundation, have begun standardizing ktfmt as the core Kotlin formatter. The project is moving into the Kotlin GitHub organization; coding conventions will be revisited; the formatter will be integrated into the toolchain and enabled by default for new projects. Code style thereby ceases to be a review-time negotiation and becomes a tooling default.

AI-Driven Development and the Stable Release of Koog 1.0

Svetlana Isakova and subsequent speakers placed AI tooling at the center of the modern Kotlin experience. JetBrains is co-leading the open Agent Client Protocol (ACP), an open standard that lets any IDE communicate with any coding agent. Developers can choose agents freely, use JetBrains AI subscriptions or their own keys, and avoid lock-in to a single model provider or payment system.

IntelliJ’s two-decade investment in code intelligence is being packaged as agent-ready skills: navigation, find-usages, refactorings ranging from simple renames to complex structural transformations. These skills make agents faster and more token-efficient. Junie, JetBrains’ own coding agent, is deeply integrated with JetBrains IDEs and can connect to the IDE even when invoked from the command line. It supports multiple model providers, allowing expensive models for planning and cheaper models for generation—benchmarks show performance on par with top competitors at up to four times lower cost. Android-specific support is available in early access, enabling agents to interact with emulators, take screenshots, and verify UI behavior including rotation.

JetBrains AI provides an agentic development environment in which multiple agents can work in parallel on different tasks—inside separate Git worktrees or Docker containers—so that concurrent modifications do not conflict. Progress is visible, attention can be directed where needed, and changes can be merged back cleanly. Cloud agents and browser-based guidance are forthcoming, as is the ability to schedule repetitive tasks on gateways. The environment itself is free; only the tokens consume budget.

Christian Ryan of Anthropic underscored the depth of collaboration. Anthropic’s official Java SDK was written in Kotlin for its ergonomics and null safety while still exposing a clean Java API. JetBrains contributed the official Kotlin MCP SDK. Claude is native in IntelliJ and Android Studio, appears as a first-party model in Junie and JetBrains AI, and benefits from the Kotlin Language Server on the CLI. JetBrains created Kotlin Sweet Bench—a suite of 110 real-world engineering tasks drawn from actual repositories—and ran it under identical conditions. Claude with Opus at extra-high settings led the results, confirming strong Kotlin proficiency.

Vadim Briliantov then announced Koog 1.0, the first mature, stable release of the Kotlin AI agent framework. One year after its experimental debut, Koog is ready for production. Agents can be embedded in mobile or backend applications with a few lines of idiomatic Kotlin. For real-world use, Koog supplies type-safe DSLs for modeling precise graph workflows with human-defined guardrails. Mercedes-Benz selected Koog for a vehicle-maintenance support agent precisely because of its modularity, traceability, and controllable logic.

Persistence allows an agent to checkpoint at any workflow node and recover from the exact same step after a crash. Spring Boot and Spring AI integration is complete: Spring AI handles LLM and RAG concerns while Koog supplies the agentic and persistence layers; instructions are injected as beans. Multiplatform targets include JVM, JS, Android, iOS, and WebAssembly. On Android, local Gemma models enable offline agents. Backend integrations cover Ktor, Amazon Agent Core, and major observability tools that expose messages, graph nodes, and per-step cost. Koog therefore unifies backend, mobile, and AI workloads under a single language.

Backend Maturity, Security Support, and Enterprise Adoption

Chantal Loncle and Josh Long illustrated the backend story. Ktor gains a Koog plugin that auto-detects LLM providers from configuration and exposes agents directly from routes with full type safety. OpenAPI generation keeps documentation synchronized with code; experimental first-party gRPC support via kotlinx-rpc generates matching protobuf source sets for every multiplatform target. Exposed reached its first stable 1.0 release earlier in the year, complete with a migration-script plugin, vector types for similarity search, and agent-assisted upgrade skills.

Starting with Kotlin 2.4 the standard library carries an 18-month security support policy: security patches from later releases are back-ported within the window, giving teams predictable upgrade planning. Empirical results show 15–20 percent faster development cycles from first change to review. Integration work continues with JUnit documentation, Maven onboarding, Micrometer coroutine support, and the Lombok compiler plugin (now alpha). Spring partnership remains first-party on both sides.

Josh Long demonstrated a production-ready agentic service built with Spring Boot, Spring AI, MCP client and security support, virtual threads, and OAuth. The resulting system is secure, null-safe, scalable, and observable. Benchmarks of MCP implementations place the JVM ahead of Node and Python by substantial margins in both throughput and latency, underscoring the runtime advantages of the platform.

Kotlin Multiplatform Expansion and Platform-Specific Advances

Márton Braun closed the technical narrative with Kotlin Multiplatform. In the preceding year the number of top apps using KMP more than doubled; McDonald’s, Booking, Duolingo, Sony Sound Connect, Alipay, Kuaishou, and Tencent Video all ship shared logic or UI to hundreds of millions of users. The KMP IDE plugin is now available on every operating system for both IntelliJ IDEA and Android Studio, supplying run configurations, Compose tooling, Swift integration, and AGP 9 support. The new project wizard adopts a clearer module structure that simplifies navigation and further modularization.

Swift export moves to alpha in Kotlin 2.4, adding support for suspending functions (awaited as Swift async) and Flows (converted to async sequences). SPM import lets Kotlin code consume Objective-C compatible packages directly. Kotlin/Native build times on the Google Docs codebase improved 25 percent with less than half the previous RAM usage—another fruit of JetBrains–Google collaboration.

Compose Multiplatform is fully stable on mobile and desktop; web has advanced to beta. Navigation 3 is stable for multiplatform use. On iOS, interop APIs allow native Liquid Glass components to overlay Compose content; parallel rendering is enabled by default and yields up to 20 percent better performance in complex layouts. Desktop Compose Hot Reload is stable and default. Web gains accessibility support and HTML interop. Kotlin/JS interop with TypeScript now includes seamless export of suspending functions as promises, giving developers two compilers that catch mistakes across language boundaries.

More than 3,600 community libraries are listed on klibs.io, reflecting the vitality of the multiplatform ecosystem.

Conclusion

The KotlinConf’26 keynote portrayed a language and ecosystem that have matured across every layer—from syntax and type system through build tooling, AI agent frameworks, backend libraries, and multiplatform UI—while remaining true to the original commitments of ergonomics and safety. Kotlin 2.4, the unified toolchain, the alpha language server, Koog 1.0, the 18-month security policy, and the doubling of multiplatform adoption together demonstrate that Kotlin is ready for the next decade of software construction, whether that construction is performed by human developers, collaborating agents, or the hybrid teams that will increasingly define the industry.

Links: