February 2026 Summaries

KotlinConf'26, taking place in Munich, offers attendees a comprehensive experience beyond just conference sessions, encouraging them to explore the city, attend workshops, and engage in networking opportunities. Participants are advised to register early to avoid lines and start with hands-on workshops to enhance their skills in areas like Kotlin Multiplatform Architecture and AI agents. The event features a keynote to set the tone, coding challenges for skill testing, and an expo for direct interaction with partners and companies. Social activities, such as a party and games, provide opportunities for relaxation and networking, while the Golden Kodee Awards honor significant contributions to the Kotlin community. Attendees are encouraged to provide feedback to improve future events and to mark their calendars for next year's conference.

Toolbox App 3.3 introduces jetbrainsd, a new lightweight background service that enhances cross-IDE features such as protocol handling by routing jetbrains:// links through the daemon instead of the app itself, thus improving reliability when accessing links from various sources. This release focuses on improving the user experience for Linux users with significant stability enhancements, including fixes for persistent widget placement and authentication issues on fresh GNOME setups, as well as improved .desktop file compatibility. Notably, plugin updates no longer require an app restart, allowing for seamless integration of new versions, and remote development receives enhancements with proper agent shutdown and error resolution. The JetBrains team encourages users to share feedback on the new features and improvements.

TeamCity's redesign focuses on improving the creation flow to enhance user experience by making it more intuitive and less cluttered, thereby allowing both new and experienced users to achieve a successful build with minimal effort. The updated design introduces a cohesive UI that simplifies the project creation process, which previously required over 20 clicks and often left users unaware of advanced features. A significant change is the separation of project creation and build configuration flows, providing clarity and predictability, along with the introduction of pipelines distinct from build configurations. The redesign also includes easier integration with version control systems, the ability to create projects directly from a VCS root, and the visibility of templates in the setup flow to streamline processes and reduce redundancy. After multiple design iterations and user testing, the first version of the new design is live, promising a more approachable and efficient experience for TeamCity users.

As applications grow in complexity, the traditional package-by-layer approach often results in tightly coupled, hard-to-maintain code, prompting the need for a modular architecture. Spring Modulith, in conjunction with IntelliJ IDEA, offers a solution by transforming monolithic applications into modular monoliths with explicit boundaries and clear public APIs. This approach organizes code by business capabilities rather than technical layers, reducing coupling and enhancing maintainability. Spring Modulith facilitates event-driven communication between modules, enabling easier extraction of modules into separate services if needed. It also supports gradual migration from existing monoliths, allowing developers to refactor incrementally. IntelliJ IDEA enhances this process by providing real-time feedback on modular structure violations and offering quick-fixes, making modularity a seamless part of the development workflow. Through continuous verification and documentation generation, developers can maintain and evolve the modular structure effectively, ensuring the codebase remains scalable and adaptable to future changes.

RubyMine has introduced a new set of tools designed to enhance AI-assisted workflows through its Model Context Protocol (MCP) integration, specifically within Ruby on Rails applications. With the release of RubyMine 2025.3, these tools allow AI models to access processed Rails-specific data directly from the integrated development environment (IDE), improving the efficiency and quality of AI interactions. The tools address challenges such as context window limitations and tool call restrictions by employing strategies like offset-based pagination and server-side filtering to manage large data sets effectively. Moreover, the toolset provides detailed descriptions and schemas to guide AI models in utilizing these tools efficiently, while also ensuring they can recover smoothly from errors. The tools are designed to be LLM-friendly, focusing on reducing the search space with minimal calls and maintaining a compact structure to accommodate multiple MCP servers.

Databao Agent achieved the top ranking in the Spider 2.0–DBT benchmark by focusing on enhancing agent reliability through improved context and a disciplined workflow, rather than relying solely on advanced models. The benchmark evaluates how well agents manage real dbt projects, requiring them to understand incomplete repositories, implement necessary SQL models, and ensure successful execution. Initially, Databao's agent struggled with consistency due to insufficient context and natural ambiguities. By providing targeted information and enforcing a structured workflow, the team reduced errors and improved performance. This approach emphasized the importance of stability and clarity over clever strategies, leading to a more controlled and predictable agent behavior. The team's insights highlight that effective agent development involves not just technical sophistication but also robust environment design, with ongoing efforts to further refine error detection and variance reduction.

TeamCity transforms traditional build log analysis by providing structured, visual, and actionable insights that facilitate faster root-cause analysis and improve build performance in CI/CD environments. Unlike raw text logs that often require tedious manual interpretation, TeamCity offers a hierarchically organized log view that allows developers to quickly pinpoint errors and performance issues. With features like visual pipeline insights, real-time updates, and historical trend analysis, TeamCity helps developers not only diagnose and fix issues more efficiently but also proactively improve their build processes. The inclusion of visual tools highlights problem areas immediately, reducing the time spent on scrolling and searching through logs, and allows for the identification of patterns that may lead to recurring issues. Additionally, the platform's ability to track and analyze build statistics lays the groundwork for future innovations, such as AI-powered build analyzers that promise even more streamlined problem-solving capabilities.

Recent research by JetBrains and UC Irvine highlights a hidden form of context switching among AI-assisted developers, where increased switching between IDEs goes unnoticed by 74% of developers, despite telemetry data indicating a rise in this behavior. This phenomenon indicates that while AI tools are perceived to boost productivity, they also introduce a subtle layer of friction that traditional behavioral policies fail to address. The solution lies in architectural changes, specifically consolidating the access layer to reduce cognitive load without sacrificing flexibility. This approach aligns with platform engineering principles that prioritize creating seamless "golden paths" for developers, allowing them to access multiple AI tools within a single environment, such as JetBrains IDEs, which now support features like Bring Your Own Key (BYOK) and Agent Client Protocol (ACP) for integrating various AI models.

Extension members in C# provide a way to add functionality to existing types without altering their definitions, which is particularly useful for built-in types or those from external libraries. Initially introduced with extension methods in C# 3.0, these enhancements were limited to methods, excluding properties, fields, or operators. However, C# 14 introduced a new syntax that allows for both instance and static properties, methods, and operators, expanding the capabilities of extension members. The new extension block syntax enables developers to define extensions within a static class, facilitating the transformation of helper methods into properties, organizing related extensions, and incorporating static constants or factories into existing types. This approach maintains compatibility with existing code while offering a more integrated feel for third-party APIs. The development environment Rider simplifies the transition from classic to new extension members through its intention action feature, supporting a seamless upgrade process.

Many enterprises are adopting AI agents but struggle to link their technical performance to tangible business value, primarily due to the gap between model metrics and business outcomes. Metrics like DORA and SPACE provide some insights into delivery velocity and developer experiences but fall short in demonstrating AI's impact on enterprise systems. Despite a high usage rate of AI among employees, only a small fraction utilize it in transformative ways, as highlighted by surveys. The challenge lies in correlating AI's technical performance with operational and financial outcomes, necessitating continuous benchmarking and measurement of real-world impact. Enterprises are encouraged to focus on operational metrics and ensure that AI systems are auditable and human-readable to achieve accountable and measurable integration into their workflows. Only by closing the gap between AI activity and business outcomes can organizations accurately assess AI's value, shifting ROI from an abstract goal to a data-driven reality.

IntelliJ IDEA 2025.3.3, a minor update of the popular integrated development environment, has been released with several significant improvements and bug fixes. Users can update to this version through the IDE, the Toolbox App, or snaps for Ubuntu, and it is also available for download from the official website. Key updates in this release include the correct handling of default properties in the MCP server output schema, ensuring no invalid schema errors occur, improved proxy configuration for downloading the IDE backend, successful proxy authentication, and accurate reflection of package annotations in the PSI model when referenced through JAR dependencies. For more detailed information on the fixes, users are encouraged to consult the release notes or report any bugs via the issue tracker.

JetBrains has introduced a new plugin for GoLand that provides guidelines to ensure AI agents like Junie and Claude Code generate modern Go code by utilizing the latest language features and best practices. This initiative addresses the issue of AI-generated Go code often being outdated due to AI models being trained on older codebases and having data cutoffs. The plugin automatically identifies the current Go version specified in go.mod and guides the AI agents to use recent features, such as slices.Contains() and new type-specific error handling introduced in newer Go versions. Users can easily enable these guidelines for Junie and Claude Code, ensuring their code remains up-to-date and idiomatic without manual intervention. This move aligns with the GoLand team's commitment to maintaining a modern Go ecosystem.

In a study conducted by JetBrains Academy, researchers explored how students interact with an AI-powered hints tool designed to aid in learning coding within programming courses. The tool, integrated into JetBrains Academy courses, provides personalized hints, leveraging static analysis and large language models (LLMs), to guide students towards solutions rather than simply pointing out errors. The study utilized process mining to analyze quantitative data from students' interactions and conducted interviews for qualitative insights, revealing distinct behavioral patterns. Students engaged with hints in varied ways: some selectively used hints to enhance personal understanding, while others combined multiple partial hints to construct solutions, indicating proactive problem-solving approaches. The research highlighted the importance of understanding student interactions with hint systems and suggested improvements for better support in adapting hints to individual learning strategies. The findings underscore the effectiveness of AI-powered tools in fostering critical thinking and adaptability in coding education.

LangChain is a versatile framework designed for building AI agents powered by large language models (LLMs) from providers such as OpenAI, Anthropic, and Google, offering a straightforward way for both beginners and advanced users to develop AI systems. It supports static and dynamic agent models, allowing agents to switch models during runtime based on context, and incorporates tools that enable agents to interact with external systems beyond just generating text. LangChain also features middleware for customizing agent behavior and implementing guardrails for safe AI operations, along with testing capabilities to ensure reliable performance. Real-world applications of LangChain include AI-powered chatbots, document question answering systems, and content generation tools, demonstrating its adaptability across various domains. LangChain integrates with development environments like PyCharm, enhancing the development experience with debugging tools. Built on LangGraph, LangChain sets a new standard for developing AI agents, combining low-level orchestration with broad compatibility across different LLMs.

TeamCity 2025.11.3 has been released as a bug-fix update for TeamCity 2025.11 On-Premises servers, addressing issues such as Quality of Life updates for the IntelliJ Platform Plugin, variable GID values for Docker, NPE login failures, and reset connection settings after changing the parent project. This update, like other minor releases, includes performance and security improvements, enhancing compatibility with integrations, stability, and build speed while ensuring better security for workflows. The update shares the same data format as all 2025.11.x releases, allowing for seamless upgrades or downgrades within this series without backup and restoration. Users are encouraged to update automatically, download the latest version from the JetBrains website, or pull the updated TeamCity Docker image, and they are invited to report any issues or seek help via the TeamCity Forum or Issue Tracker.

JetBrains has introduced a Java to Kotlin (J2K) converter extension for Visual Studio Code, aiming to facilitate the conversion of Java files to Kotlin code seamlessly within the popular editor. Recognizing the widespread use of Visual Studio Code among developers, JetBrains has developed this extension to reduce the manual effort involved in migrating legacy Java codebases or switching languages mid-project. The extension leverages the same engine used in JetBrains' primary IDEs, ensuring reliable and idiomatic Kotlin code conversion. This initiative is part of JetBrains' broader commitment to supporting Kotlin developers across different platforms, complementing other tools like the Kotlin Language Server Protocol. Users are encouraged to provide feedback on the extension through YouTrack or the Visual Studio Marketplace.

AI tools have become integral to modern software development, seamlessly integrating into developers' workflows from coding and refactoring to documentation and testing. These tools, which were once experimental, are now essential, used by developers to streamline processes and maintain code quality as projects grow. According to the JetBrains State of Developer Ecosystem Report 2025, AI tools such as GitHub Copilot, JetBrains AI Assistant, and Tabnine are widely adopted, with developers choosing tools based on integration quality, code accuracy, and privacy. Regional preferences vary, with North America favoring mainstream tools and China leveraging domestic models. Despite their widespread use, privacy and security concerns remain significant barriers to adoption. Developers desire tools that offer higher code quality, deeper IDE integration, and better privacy controls, indicating an expectation for AI tools to evolve into more reliable and collaborative partners. As these tools advance, they are shifting from being seen as futuristic possibilities to indispensable elements of the software development process.

The recent update to the IntelliJ Platform's editor focuses on enhancing user experience by introducing smoother caret animations and new selection behavior. The editor now highlights only the selected text, avoiding the inclusion of blank spaces at the end of lines, which clarifies the selection process for users. Additionally, the introduction of smooth caret movement, a long-requested feature, aims to make navigation more intuitive and visually pleasing without compromising on typing responsiveness. To address different user preferences, the update offers two modes for caret movement: Snappy, which provides quick yet smooth transitions, and Gliding, for more visible motion. These changes are part of ongoing efforts to modernize the IDE with a cleaner aesthetic and increased functionality, aligning with the Islands UI theme. Available in the early access builds of JetBrains IDEs, these features are open to user feedback for further refinement.

Databao, a recent product from JetBrains, has joined the Open Semantic Interchange (OSI), an initiative led by Snowflake and other industry leaders to create a shared, vendor-neutral standard for semantic metadata. This collaboration aims to enhance interoperability and governance of semantic models, making semantic context portable across various tools and platforms, thereby reducing complexity and facilitating the adoption of AI and analytics tools. Databao aligns with OSI's principles by emphasizing scalable trust through a continuously refined semantic layer and offering flexibility without sacrificing governance. The product allows data teams to maintain control over their data sources and supports the creation of AI-native analytics experiences, enabling users to query data in plain language. Databao's components, including a context engine and data agent, can operate independently or integrate with existing infrastructure, promoting a community-driven approach to semantic model sharing.

In a JetBrains livestream, Vitaly Bragilevsky and Carl Lerche, the creator of Tokio, discussed the evolution of asynchronous Rust, focusing on Tokio's role as the primary async runtime for high-performance networking. The conversation covered the architectural choices behind Tokio, the challenges developers face, and the future direction of the ecosystem. TokioConf, the first conference dedicated to the Tokio ecosystem, highlights its maturity and growth ten years after its inception. Async Rust goes beyond performance, offering improved event-driven system structuring through features like timeouts and cancellation management. The discussion also touched on the history and design decisions that led to Tokio's dominance, such as its adoption of proven scheduling patterns from languages like Go and Erlang, and the potential benefits and complexities of io_uring. Additionally, the challenges of cooperative scheduling and debugging in async Rust were addressed, as well as the potential for Rust to expand into higher-level web application frameworks with initiatives like Toasty, designed to improve productivity and ergonomics in data modeling and querying. The session closed by emphasizing Rust's established role in infrastructure-level systems and its potential growth into full-stack development.

KotlinConf 2026 is shaping up to be an exciting event with a full schedule of talks, workshops, and speakers now available online, offering attendees a comprehensive conference experience. The Kotlin Foundation has launched a mentorship program to aid newcomers in making their first open-source contributions, providing guidance from experienced maintainers and potential rewards like a trip to KotlinConf 2026. Kotlin 2.3 introduces enhancements such as smarter checks and improved APIs, while Ktor 3.4.0 and Compose Hot Reload 1.0.0 bring significant updates to server-side Kotlin and UI development, respectively. The conference will also feature Golden Kodee Community Awards to recognize significant contributors to the Kotlin community, with finalists announced in April and winners revealed live at the event. Additionally, Kotlin's real-world application is highlighted through Amazon Fashion's migration of a large backend service from Java to Kotlin, resulting in more efficient and testable code. The text also discusses new tools and integrations like Qodana for Android Kotlin and Koog with the Agent Client Protocol, as well as a guide for adopting Kotlin in Java-heavy environments.

TeamCity's pretested commits feature offers a proactive solution to the common issue of code that works locally but fails in shared environments, by ensuring that only verified, stable code reaches the main branch. This workflow reverses the traditional build-after-commit process by allowing developers to build and test changes on TeamCity servers before committing them, significantly reducing integration issues and enhancing team productivity. Through the use of remote runs and IDE integration, TeamCity can validate code changes by running a full build and test cycle, ensuring only successful builds are merged, thus maintaining branch stability and enhancing continuous delivery efforts. While pretested commits are most beneficial for teams prioritizing stability and frequent releases, they are best supported by comprehensive and reliable test suites. The approach integrates seamlessly with various version control systems and can be customized to fit different project requirements, ultimately providing a robust framework for ensuring code quality and reducing disruptions in collaborative development environments.

GoLand, a JetBrains IDE, facilitates the transition to Go 1.26 by offering syntax updates that highlight and suggest modernization opportunities within existing Go projects, allowing developers to seamlessly upgrade their code without altering its behavior. As developers make minor changes, such as adding fields or adjusting logic, GoLand detects outdated patterns and provides focused inspections with quick-fixes for issues like type-safe error unwrapping with `errors.AsType` and pointer creation with `new()`. These updates are indicated by a blue underline, signifying that the code is safe to modernize. GoLand enables developers to apply these changes project-wide through various entry points like the Refactor menu or the Problems tool window, which collects updates and displays before-and-after differences for review. This approach allows the migration to be integrated into daily work as a series of small, manageable updates, rather than a large, separate project, thus keeping the codebase current and efficient.

The tutorial explores the concept of modular monoliths as a balanced architectural approach that combines the simplicity of single-unit deployment with the structural benefits of modular design. Unlike traditional tightly coupled monoliths or the complexity of microservices, modular monoliths organize applications into distinct modules based on logical boundaries or business domains, allowing for independent development and maintainability. Using Kotlin and Spring Modulith, developers can implement this architecture by defining clear interfaces and employing tools for module verification, testing, and observability. The guide highlights the advantages of modular monoliths, such as simplified deployment and reliable testing, while acknowledging scenarios where they may not be suitable, such as systems with independent scaling needs or diverse tech stacks. The approach is particularly beneficial in early-stage development or complex business domains, offering a path to evolve into microservices if necessary.

Anton Bragin's opinion piece, reflecting on insights from the NeurIPS 2025 AI research conference, explores the evolving understanding of AI's role and capabilities, particularly in contrast to human intelligence. It highlights Zeynep Tufekci's argument that society often misinterprets the impact of technological advances, focusing on familiar risks while overlooking new challenges. The piece emphasizes that AI, particularly large language models (LLMs), represents a distinct form of intelligence that excels in structured tasks but struggles with practical, real-world applications due to its fundamentally different learning process. This distinction necessitates a shift in perspective, where AI is not seen as a substitute for human intelligence but as a complementary force requiring changes in workflows and development environments. As AI continues to advance, the software development ecosystem is expected to evolve to better integrate AI's unique strengths, ultimately leading to new practices and tools that align with AI-driven processes. The article also references Richard Sutton's "bitter lesson," which suggests that more general AI methods outperform human-designed shortcuts over time, implying the need for development processes that maximize AI utilization to avoid bottlenecks as technology scales.

JetBrains Academy's February Digest highlights a range of events, learning opportunities, and updates aimed at developers and students in 2026. The digest promotes the IntelliJ IDEA Conf 2026, a virtual conference focusing on the JVM ecosystem, and Python Unplugged, a live YouTube event featuring insights from key figures in the Python community. It also encourages participation in the JetBrains Youth Math Challenge and the Blackbox Cup, both designed to test problem-solving skills, with the latter being important for scholarship consideration. The digest showcases the best programming courses of 2025 and announces up to 40 full scholarships for a Computer Science and Artificial Intelligence BSc program at Neapolis University Pafos. New courses available on Coursera include a Python course with full PyCharm integration, and a free AI-assisted programming course developed by JetBrains and Nebius engineers. Tech insights focus on preparing for the future of programming in an AI-driven world, and the Hyperskill plugin now offers a standalone experience for JetBrains IDE users.

The recent update in IntelliJ IDEA now supports Markdown in Scaladoc for Scala programming, offering a more simplified and widely-used syntax compared to the older Wikidoc format. While Wikidoc provided advanced features for organizing large documentation volumes, Markdown's simplicity and readability make it a more accessible choice for code comments, already familiar to developers through its use in README and other documentation files. In Scala 3, Markdown becomes the default syntax for Scaladoc, allowing for easy formatting of headers, lists, block quotes, text styles, links, code anchors, and tables, with backward compatibility to Wikidoc available via a specific directive. The IntelliJ Scala Plugin aids in this transition by automatically supporting Markdown syntax and offering multiple ways to render Scaladoc directly in the editor, enhancing the documentation process for developers.

The State of Rust 2025 report provides an in-depth analysis of the Rust programming language's evolving ecosystem, as detailed in the JetBrains Developer Ecosystem Survey Report 2025. Rust remains popular and in demand across various contexts, including learning, hobby, and professional use, with a significant influx of new users and a strong base of experienced developers. This popularity is driven by Rust's performance, memory safety, and reliability, alongside improving tooling and resources that make it easier to adopt. Developers from diverse programming backgrounds, such as Python, Java, and C++, are integrating Rust into their projects for its capability to coexist with or replace existing languages, especially in production environments like Linux, Windows, and macOS. Rust's role has expanded beyond systems programming to backend, web development, and AI-related tooling, demonstrating its versatility. The report also highlights the cautious yet optimistic integration of AI tools in Rust workflows, with developers using AI assistants like ChatGPT and GitHub Copilot to enhance productivity without compromising on the language's core values of correctness and safety. Overall, the data suggests a stable and promising future for Rust, supported by a balanced ecosystem of newcomers and veteran developers, ongoing enhancements in tooling, and its application across a wide range of domains.

AI coding models have become integral to modern software development, with large language models (LLMs) like GPT-5, Claude, and Gemini leading the way in providing code completion, refactoring, debugging, and documentation assistance. These models, as reported in the JetBrains Developer Ecosystem Report 2025, are chosen based on factors like accuracy, speed, integration, cost, and security, with developers prioritizing models that seamlessly integrate into their workflows. While proprietary cloud-based models offer ease and scalability, open-source or locally deployed models are favored for greater data control and customization. The report highlights the diverse preferences among developers, with individual developers focusing on usability and cost, while organizations emphasize compliance and governance. The choice of AI model is critical, depending on specific needs such as data privacy, integration with tools like JetBrains IDEs, and enterprise requirements. As AI capabilities continue to expand, these models are increasingly adopted across the industry, transforming how developers approach coding tasks.

Python Unplugged on PyTV is a newly announced free online Python conference organized by the PyCharm team, set to take place on March 4th, 2026, streaming from Amsterdam. The event aims to make the experience of attending a Python conference accessible to everyone, regardless of their location, by featuring 15 well-known speakers from global Python communities discussing topics like core Python, AI, community engagement, web development, and data science. Participants can engage with the speakers and other attendees through a Discord chat, and the event will include interactive elements such as games, quizzes, and chances to win prizes and unique conference swag. Additionally, for those in Amsterdam, there is an opportunity to attend a PyLadies meetup to meet some of the speakers in person.

The JetBrains Foundation is offering up to 40 full scholarships for the Computer Science and Artificial Intelligence BSc program at Neapolis University Pafos, starting in 2026, doubling the amount from previous years. The scholarships are comprehensive, covering tuition, accommodation, medical insurance, visa fees, and providing a monthly stipend of €300. Admissions will begin earlier than usual, starting on February 2, 2026, with application deadlines and entrance tests scheduled in April and June. Graduates of this program are highly sought after by leading IT companies such as Meta, Google, and JetBrains, highlighting the program's prestige and the opportunities it provides. Interested applicants can learn more about the program and admissions process during a livestream event on February 25, 2026, and can reach out via Telegram or email for further inquiries.

JetBrains highlights four notable open-source projects within the .NET ecosystem, each demonstrating the impact of developer experience on the sustainability of ambitious projects. Avalonia UI, a cross-platform UI framework, aims to become the leading .NET UI toolkit and has recently introduced new tools and controls. MudBlazor, a .NET-first Blazor component library, emphasizes stability and test coverage, with plans for substantial refactoring using tools like ReSharper. LINQ to DB, a mature data access library, focuses on improving expression tree translation and enhancing performance, leveraging JetBrains IDEs for efficient development. PeachPie, a PHP compiler for .NET, explores running PHP frameworks on .NET, with plans for future compatibility with Laravel and Symfony. These projects exemplify how effective tooling and developer ergonomics enhance maintainability and innovation in open-source development.

Join the Go 1.26 Release Party livestream on February 19, 2026, to explore the newest features of Go 1.26 with experts Anton Zhiyanov and Alex Rios. The event will highlight significant updates through live coding sessions and practical examples, with Zhiyanov providing in-depth coverage of the changes and Rios demonstrating how GoLand supports the new release from its inception. The livestream promises a mix of technical insights, hands-on demonstrations, and interactive discussions, aimed at helping developers confidently integrate Go 1.26 into their work. Zhiyanov, a seasoned backend developer and Go educator, is noted for his contributions to open-source projects and educational content on Go concurrency, while Rios, an experienced engineer and author, focuses on developer platforms and system programming, sharing his expertise at conferences and through various publications.

Databao, a new tool from JetBrains, aims to enhance AI-assisted analytics by providing reliable semantic context for data teams, allowing business users to engage with data in plain language while maintaining accuracy and control. The platform offers a context engine for extracting schema and metadata, which ensures consistent and reusable business logic, and a data agent available as an open-source Python SDK for querying, cleaning, and visualizing data. Databao is designed to grow with organizational needs, avoiding vendor lock-in and supporting diverse production environments. The initiative recently achieved a first-place ranking in the DBT track of the SPIDER 2.0 Text-to-SQL benchmark and joined the Open Semantic Interchange (OSI) to help establish a shared standard for semantic models. JetBrains invites data teams to collaborate on building a proof of concept to further refine Databao's capabilities and usability.

DotInsights by JetBrains is a newsletter dedicated to recent developments in .NET and software development, featuring a variety of topics such as new capabilities in C# 14, guidance on using Agent Skills in GitHub Copilot, and insights into sustainable coding practices. It showcases articles on implementing enterprise patterns in C#, making coding workflows more efficient, and leveraging AI in software design. The newsletter also highlights updates and new features in JetBrains' development tools like Rider and ReSharper, offering early access programs and tips for writing better AI prompts. Additionally, it covers practical advice on avoiding common pitfalls in ASP.NET Core and insights into the future of game development.

February's issue of "Java Annotated Monthly" brings a calm yet insightful look into the tech world, particularly focusing on the evolution and future of Java. With Trisha Gee as the featured content guest, the newsletter delves into the latest updates in Java, including the significance of running on the latest LTS version, Java 25, and the anticipated features of Java 26. It highlights Brian Goetz's insights on data representation in Java and carrier classes, while also providing practical tutorials and tips for developers. The issue covers the maturation of Kotlin, AI's increasing role in development, and a range of tools and frameworks like Spring and Quarkus for cloud-native Java. Additionally, it includes updates on conferences and community events, reflecting on leadership and learning within the tech community. This edition is rich with ideas, offering a blend of technical deep dives, practical advice, and community insights, making it a resourceful read for developers looking to stay informed and inspired.

Qodana, a static code analysis tool from JetBrains, extends the functionality of its IDEs to continuous integration environments by allowing users to add custom code inspections. This process is demonstrated through a practical example where a custom inspection ensures that Kotlin classes in a "service" package have a "Service" suffix, which is enforced via a plugin developed using the IntelliJ Platform Plugin Template. The guide provides detailed steps on initializing the project, adjusting properties, declaring dependencies, creating the inspection in Kotlin, and packaging the plugin. It also covers the integration of the custom inspection into CI/CD pipelines using Qodana and how to run it in different environments, including locally via Docker, in the JetBrains IDE, and through the JetBrains Marketplace. The process highlights how Qodana enhances code quality and adherence to coding conventions by producing comprehensive analysis reports.

Starting from version 2026.1, IntelliJ-based IDEs will natively support Wayland on compatible Linux desktop environments, reflecting Wayland's rising status as the primary display server. This transition aims to enhance user experience by collecting feedback during early access program releases before a broader rollout. Native Wayland support will replace the X application mode, offering improvements like enhanced stability, drag-and-drop functionality, and input methods support, although some user interface differences may arise due to Wayland's distinct technical architecture. Despite these changes, X11 will remain supported, allowing users to switch back using XWayland for compatibility. The transition, facilitated by the WLToolkit subsystem and contributions to the OpenJDK project Wakefield, marks a significant step in developing a stable and integrated Wayland experience. Users' feedback has been crucial in identifying and prioritizing enhancements, with the upcoming version addressing many reported issues to improve stability, performance, and desktop integration.

JetBrains has launched the JetBrains Console, a tool designed to enhance AI management and analytics capabilities for organizations, allowing them to oversee AI usage and costs across teams. As AI becomes integral to development workflows, the console provides essential governance and observability features to manage AI responsibly. It enables organizations to control access to AI tools, manage AI credits, and configure data collection, all directly within developers' JetBrains IDEs. The console offers insights into AI adoption patterns, usage trends, and the impact of AI on development work, supporting better budget planning and decision-making. It also includes metrics on AI-generated code acceptance and the influence of AI on codebases, helping organizations refine their AI tool usage. Available at no additional cost to commercial customers with AI licenses, the JetBrains Console supports role-based access for managing AI settings and viewing analytics, with future enhancements planned to further improve AI governance and analytics.

KotlinConf in Munich offers a variety of hands-on workshops on May 20, allowing attendees to delve into specific areas of interest related to Kotlin. Participants can choose from sessions focusing on asynchronous programming with Kotlin coroutines, building shared UI across multiple platforms using Compose Multiplatform, enhancing Kotlin Multiplatform architecture, developing high-performance backends with Spring Boot and Kotlin coroutines, integrating AI in Kotlin with Koog, and transitioning object-oriented code to functional Kotlin. These workshops, led by Kotlin experts, provide practical learning experiences for developers seeking to enhance their skills and are accessible to those attending the conference with limited seating available.

Koog, a Kotlin-based framework for building AI agents, integrates seamlessly with the Agent Client Protocol (ACP) to facilitate the creation of ACP-compliant agents that can be connected to IDEs, such as JetBrains. The ACP is an open protocol that standardizes communication between agents and clients, offering SDKs for various programming languages to streamline the integration process. Koog provides a range of features, including support for multiple agent strategies, LLM providers, and protocols like MCP and A2A, making it versatile for developing agents across different platforms. By utilizing Koog’s native integration with ACP, developers can build coding agents capable of reading and editing files directly within an IDE, as demonstrated through the creation of a sample Koog agent. This setup allows developers to leverage ACP features like session management and client-agent communication, enabling efficient agent integration with IntelliJ-based IDEs via standard I/O transport.

The Kotlin Foundation has introduced the Kotlin Ecosystem Mentorship Program, designed to pair experienced open-source maintainers with new contributors to facilitate their first meaningful contributions to Kotlin projects. This initiative aims to address challenges faced by new contributors, such as understanding project structures and gaining confidence, while also combating the influx of low-quality contributions prompted by AI advancements. The program, which will initially involve about 10 mentor-mentee pairs from mid-February to early April, seeks to guide participants through the contribution process, culminating in at least one successful project contribution per pair. Participants will receive Kotlin-branded merchandise, and one lucky pair will win a trip to KotlinConf 2026. The program aspires to boost the open-source ecosystem by fostering new regular contributors who continue to support projects beyond the mentorship.