January 2026 Summaries

Qodana for Android is a tool developed by JetBrains to enhance code quality for Android teams using Kotlin, focusing on automation and consistency in the development process. While not intended to replace Android-specific tools like Android Lint, Qodana complements existing tooling by running Kotlin static analysis, aligning IDE inspections with CI systems, and providing a scalable approach to quality management. It addresses common issues such as code complexity and visibility problems, which can impede refactoring efforts, by acting as a quality gate that identifies high-impact issues before code is merged. This is particularly beneficial for large teams or projects with multiple modules, as it ensures consistent quality standards across different environments. Qodana allows for gradual adoption, enabling teams to baseline existing issues and prevent new regressions, making it suitable for both legacy and new Android projects. By treating Kotlin as a strategic language across mobile and non-mobile components, Qodana helps maintain consistent standards and supports the broader goal of embedding code quality into the development process as an automated, shared responsibility.

The latest JetBrains Marketplace News Newsletter for Q4 2025 offers a comprehensive update for plugin developers, highlighting new features and tools available for enhancing their development process. Integration tests are now part of automated moderation, providing detailed reports to ensure plugin compatibility, although they are not yet available for paid plugins or those designed for Android Studio. The newsletter also introduces a unified vendor type to simplify vendor logic and improve workflow consistency. Updates to the IntelliJ Platform Plugin Template, IntelliJ Plugin Verifier, and IntelliJ Platform Gradle Plugin are detailed, showcasing improvements in compatibility, setup simplification, and the introduction of new APIs. The newsletter underscores the importance of integrating the Plugin Verifier into CI pipelines to preemptively catch issues and offers resources for learning about recent changes, such as the new Islands Theme and the Modular Plugins model. Additionally, it invites developers to explore recordings from the JetBrains Plugin Developer Conference 2025 to gain insights into various aspects of plugin development.

JetBrains has released the 2025.3.2 updates for ReSharper, Rider, and other .NET tools, which can be accessed through the tools themselves, the Toolbox app, or their website. This update introduces enhancements such as the Agent Client Protocol (ACP) agent registry in Rider, allowing users to browse and install AI agents directly from a curated registry without requiring custom integrations. Notable fixes include the restoration of plugin suggestions based on project dependencies, correct navigation for the "Go to Implementation" feature, accurate deployment of .NET MAUI apps on Android devices, and proper handling of multi-targeted .NET projects. Additionally, improvements to the Hot Reload function and Unity plugin in ReSharper Command Line Tools were made, alongside the resolution of several inspection issues. The update also addresses memory profiling issues and ensures correct alignment for Unreal Engine code vision inlays. As this is the final update of the year, JetBrains expresses gratitude to users and extends wishes for a happy holiday season.

As of 2025, the game development industry is experiencing significant changes, notably with increased layoffs leading to decreased job security, which has made developers among the least confident in the tech sector. Unity continues to dominate as the preferred engine for indie and mid-sized studios, while the open-source Godot engine gains popularity for its flexibility and community-driven nature. Mobile and desktop platforms, particularly Android, Windows, and iOS, are the primary focus for indie developers due to their broader user bases. JetBrains Rider has become the most favored IDE for indie developers, surpassing Visual Studio and VS Code, due to its comprehensive features and seamless integration. AI technology has transitioned from experimental to essential in game development, with tools like ChatGPT, GitHub Copilot, and JetBrains AI Assistant becoming regular parts of developers' toolkits, while the newly released AI coding agent, JetBrains' Junie, is quickly gaining traction, particularly among AAA studios interested in integrating AI into their workflows.

IntelliJ IDEA has introduced first-class support for Spring Data JDBC, streamlining the development process by providing similar functionality as with JPA, including entity generation from database tables and the creation of migration scripts for tools like Flyway and Liquibase. The IDE now offers improved handling of JDBC entities, repository method autocompletion, and support for both code-first and DB-first workflows, allowing developers to maintain consistency between their domain models and database schemas. IntelliJ IDEA's capabilities include auto-detection of Spring Data repositories, reverse engineering of database schemas into entities, and the ability to generate and review migration scripts to ensure database changes are safely applied. While AI can assist with drafting migrations, IntelliJ IDEA emphasizes the importance of developer oversight in reviewing changes to prevent potential issues.

PyCharm 2025.3.2 introduces free support for Google Colab, enhancing the integration of local IDE workflows with cloud-based notebook experiments. This update allows users to bring Google Colab notebooks into PyCharm, utilizing IDE features like refactoring and navigation to manage larger projects and extended development sessions. The integration is seamless, requiring users to open a Jupyter notebook in PyCharm, select Google Colab from the Jupyter server menu, sign in to their Google account, and create a Colab-backed server. This setup ensures that notebooks operate normally, with inline outputs and visualizations available directly in the editor. PyCharm also facilitates the management of dependencies, allowing users to upload files from their local environment if they are missing on the Colab machine. This integration enables smooth transitions between local work, remote execution, and cloud resources, maintaining workflow consistency within PyCharm.

The text explores the concept of vendor lock-in versus strategic partnership in the context of Continuous Integration/Continuous Deployment (CI/CD) platforms, challenging the conventional view that vendor-specific solutions are inherently limiting. It argues that any technology investment involves some level of lock-in and suggests evaluating CI/CD solutions based on their ability to meet organizational needs without imposing undue restrictions. The article outlines the risks associated with CI/CD platforms, including technical, financial, operational, and strategic risks, and offers a framework for assessing potential solutions. It emphasizes the importance of choosing vendors with open APIs, transparent pricing, and collaborative roadmapping to foster a strategic partnership. The text also compares the pros and cons of building a DIY CI/CD solution versus using an integrated platform, suggesting that the choice depends on the organization's need for control versus the desire for streamlined productivity and vendor-managed reliability.

The newly launched ACP Agent Registry offers a comprehensive directory of AI coding agents, integrated into JetBrains IDEs and Zed, enabling developers to easily discover, install, and switch between various AI agents to enhance their coding workflows. The Agent Client Protocol (ACP) serves as an open standard that ensures interoperability among AI coding agents across different editors, eliminating vendor lock-in and allowing developers to choose their preferred tools freely. This registry simplifies the process of integrating AI agents by allowing developers to install agents with a single click, while also supporting the ongoing evolution of AI-assisted development through community-driven contributions. For agent developers, listing in the registry provides instant access to a large user base, promoting competition based on quality rather than exclusivity. The initiative fosters an open ecosystem, encouraging experimentation and diverse agent use to suit individual preferences and needs.

Rust and JavaScript/TypeScript (JS/TS) are increasingly used together in software development due to their complementary strengths and growing adoption across various domains. While JS/TS offers a vast ecosystem and rapid iteration, ideal for front-end and full-stack development, Rust excels in performance, memory safety, and reliability, making it suitable for backend, systems programming, and WebAssembly (Wasm) modules. Modern architectures often leverage Rust for performance-critical components within JS/TS applications via WebAssembly, enabling seamless integration and enhanced performance. The collaboration between these languages is evident in projects where Rust handles intensive computations and JS/TS manages the user interface and application logic. This hybrid approach is favored by companies like Figma, Cloudflare, and Biome, showcasing Rust's role in enhancing speed and safety without disrupting the flexibility and rapid development capabilities of JS/TS. As both ecosystems evolve, developers increasingly adopt Rust for its predictability and security, while continuing to rely on the extensive JS/TS ecosystem for its versatility and ease of use.

In 2025, the JetBrains Content Creators Program celebrated significant achievements, with over 200 new members joining and creating impactful content that highlights the integration of JetBrains tools in their work. Creators like Carlos Belenguer Jover and Miguel Teheran shared personal success stories of leveraging these tools to enhance their content and reach, while others, such as Anton Martynyuk and Adam Myhre, achieved substantial growth in their audiences and recognition in their fields. The program also spotlighted creators who ventured beyond digital content, like Jens Oliver Meiert and Ashley Allen, who authored books using JetBrains IDEs to streamline their writing processes. Furthermore, the program emphasized the importance of community and innovation, with creators like Serena Sensini praising the ecosystem's ability to introduce new technologies through plugins and marketplaces. The program's collective stories illustrate how creators are shaping the developer experience and underscore JetBrains' role in supporting and empowering these endeavors.

In 2025, the Scala Plugin for IntelliJ IDEA saw significant advancements, including enhanced support for Scala 3 features such as named tuples, "better fors" in for-comprehensions, and the introduction of the "into" modifier, all aimed at closing the feature gap with the evolving Scala compiler. The plugin also improved its sbt integration, enabling a new default modules layout, and prepared for sbt 2.0 support. X-Ray mode received updates to provide better insights into code usage, while performance enhancements reduced editor lag and UI freezes. JetBrains' annual developer survey highlighted Scala 3's growing popularity, with 59% of respondents using it regularly, and a shift in the landscape of unit testing frameworks and libraries, where ScalaTest maintained its lead, but MUnit, ZIOTest, and ZIO gained traction. The company also expanded its educational efforts with a new series of YouTube videos and maintained a strong presence in the Scala community by sponsoring major conferences and delivering talks on plugin features and productivity tools.

In the fifth installment of a series on building AI agents in Kotlin, the focus is on teaching agents to manage their memory by implementing a strategy of smart compression to prevent context overflow. The series has been utilizing the GPT-5 Codex model, which performs well on simple tasks but struggles with complex tasks due to context window limitations. A new approach, singleRunStrategyWithHistoryCompression, is introduced, which allows agents to compress their history intelligently, retaining crucial context while discarding verbose details. This compression is triggered when history size exceeds set thresholds, ensuring that agents can handle longer tasks without crashing due to context limits. Users can customize the compression strategy by defining specific concepts that the agent must remember, thus maintaining the necessary information to continue tasks effectively. This enhancement enables agents to perform tasks efficiently within token budgets and lays the groundwork for further exploration into agent planning and reasoning. The complete implementation is available on GitHub for those interested in further development.

The blog post discusses the significant improvements made to variable inspection speed in the Rider development tool for Unreal Engine, achieving a performance enhancement of up to 87 times faster on warm runs and 16 times faster on cold ones, along with a reduction in debugger memory usage to just over a third of its previous consumption. This was accomplished by rewriting the expression evaluator to replace the reliance on LLDB's Clang-based evaluator, which was slow and difficult to maintain, especially with complex Natvis expressions used for type visualization in debugging. The new evaluator not only improves performance but also enhances reliability, notably with core dumps, and is available in the Rider 2026.1 Early Access Program. These advancements also bring performance boosts to other debugging features like conditional breakpoints, making the debugging process more efficient for developers working on large Unreal Engine projects.

KotlinConf 2026 is an upcoming event that will gather developers from around the globe to explore the latest advancements in Kotlin, featuring leading experts and innovators in the field. Building on the success of KotlinConf 2025, which attracted participants from over 50 countries, the 2026 conference promises a lineup of inspiring talks, in-depth workshops, and networking opportunities for Kotlin enthusiasts. The initial set of speakers has been announced, highlighting individuals who are at the forefront of shaping the language and its ecosystem. Attendees can look forward to engaging with the community and discovering what lies ahead for Kotlin, with more speakers and the complete schedule to be unveiled soon.

The upcoming livestream titled "From Detection to Remediation: Wiz in Your JetBrains IDE" will feature Daniel Velikanski from Wiz, showcasing how the Wiz plugin integrates cloud security insights directly into JetBrains IDEs to help developers identify and address security risks while coding. Scheduled for February 5, 2026, this session will demonstrate how the plugin aids in detecting misconfigurations, vulnerabilities, and exposed secrets, embedding security seamlessly into the development workflow. Daniel Velikanski, with his extensive background in software engineering and product management at Wiz, will lead the session, supported by Evgeny Borisov from JetBrains, who has vast experience in Java development and advocacy. Attendees will have the opportunity to ask questions during the livestream, with any unanswered queries addressed in a subsequent blog post.

Jenkins, a longstanding CI/CD tool, is increasingly seen as outdated due to its plugin compatibility issues, slow builds, and complex configurations, prompting many organizations to consider migrating to more modern platforms like TeamCity. The article provides a comprehensive migration planning kit to facilitate this transition, including a readiness assessment to gauge an organization's preparedness and pain levels with Jenkins. It outlines a five-phase migration plan: discovery and assessment, pilot setup, incremental migration, optimization, and full cutover, emphasizing the importance of communicating the benefits to leadership to gain buy-in. TeamCity offers advantages such as Kotlin DSL for pipeline logic, built-in test intelligence, and enterprise orchestration capabilities that aim to simplify and enhance CI/CD processes. The guide stresses the necessity of a strategic and phased approach to migration, allowing for parallel operation with Jenkins and reducing risk through incremental adoption, ultimately aiming to improve developer productivity and system reliability.

Ktor 3.4.0 introduces several enhancements focused on improving stability and addressing outstanding issues, including the completion of OpenAPI generation for dynamic endpoint documentation, duplex streaming support for OkHttp enabling simultaneous request and response data flow, and Zstd compression for high efficiency in the compression plugin. Additionally, the new HttpRequestLifecycle plugin allows for cancelling in-flight HTTP requests when clients disconnect, enhancing resource management through structured concurrency. These updates aim to bolster Ktor's performance and readiness for future development, encouraging community involvement through the Ktor Early Access Program and offering resources for starting new projects at start.ktor.io.

Spring Debugger, introduced in May 2025, has become a popular tool among developers for demystifying the inner workings of Spring Boot applications, garnering over 300,000 downloads by the end of that year. The latest update introduces remote debugging capabilities without the use of debug agents, addressing frequent user requests. This remote debugging feature varies depending on the servlet container used, with Apache Tomcat allowing immediate context inspection, while Jetty and Undertow experience a slight delay until the first HTTP request. The process mirrors traditional JVM remote debugging by using an open debug port, and although it supports embedded containers, there are limitations such as the absence of a database structure view. The developers are considering optional agent-based extensions for environments requiring deeper introspection, emphasizing their commitment to user feedback and continuous improvement.

Exposed 1.0 marks a significant milestone for the project by introducing several new features, most notably R2DBC support, which allows for reactive driver integration with the Exposed SQL DSL approach. This release also brings performance enhancements, bug fixes, and a stable API that ensures no breaking changes until the next major update. The release supports Spring Boot 3 and 4, offering improvements like GraalVM native image support and better transaction management. The Exposed team expressed gratitude to the community and contributors for their support, with an invitation to join discussions on Kotlin Slack.

Developer experience (DevEx) is closely linked to engineering performance, which is pivotal for gaining a competitive edge, yet many teams are hindered by outdated CI/CD systems like Jenkins that cause inefficiencies and limit growth. Modern platforms such as TeamCity offer significant improvements by reducing deployment times, lead times, and change failure rates, which in turn boost developer productivity, feature delivery, and operational reliability. Legacy systems often lead to significant time wastage and increased operational risk due to their complexity and the requirement for manual interventions, which also contributes to talent turnover. Incremental fixes on these outdated systems typically fail due to the inherent architectural limitations, leading to even more complexity. TeamCity, with its intuitive UI, seamless integration with version control systems, advanced testing capabilities, unified monitoring, and scalable architecture, offers measurable returns on investment by enhancing developer productivity and streamlining operations. Organizations that transition to modern CI/CD platforms can expect a noticeable improvement in performance and competitive positioning, while those that do not may fall further behind as the performance gap widens.

IntelliJ IDEA 2025.3.2 has been released, offering several improvements and bug fixes to enhance user experience. Users can update to the new version through the IDE, the Toolbox App, or download it from the website, with Ubuntu users having the option to use snaps. Notable refinements include the elimination of flickering in the Terminal tool window when using CLI tools, improvements in credential storage and settings synchronization for remote development, and enhanced run configuration handling in the Services tool window. Detailed information about the addressed issues can be found in the release notes, and users are encouraged to report any bugs via the issue tracker.

The Early Access Program (EAP) for Rider 2026.1 has commenced, offering users a preview build with new features and enhancements. Participants can try the latest updates such as enhanced C# support, Azure DevOps integration for repository cloning, and NuGet PowerShell commands within the Package Manager Console. The release also introduces mixed-mode debugging on Windows, enabling simultaneous debugging of managed and native code, and a .NET Disassembler for inspecting C# code assembly output. Additionally, Rider now features improved integration with the Godot Editor and enhanced Natvis expression evaluation for C++ debugging. Users are encouraged to explore these developments and provide feedback to help refine the final release.

The ReSharper 2026.1 Early Access Program (EAP) introduces a range of new features and improvements aimed at enhancing productivity and code quality for developers. Key updates include smarter code generation and completion for C#, with features like the ability to generate partial member definitions and improved logging workflows. Additionally, new inspections have been added to enhance runtime safety, such as detecting problematic ImmutableArray initializations and inefficient HttpClient usage. Performance optimizations have been made to reduce runtime overhead, and C++ language support has been expanded to include initial support for C++23 floating-point types, among other improvements. The update also enhances project model handling, particularly for WinUI 3 projects, and integrates Dynamic Program Analysis into a broader performance monitoring framework. Users are encouraged to explore these updates and provide feedback to refine the features before the final release.

OpenAI's Codex is now integrated into JetBrains IDEs, offering developers a powerful AI tool for handling coding tasks directly within their development environment. Users can access Codex through a JetBrains AI subscription, a ChatGPT account, or an OpenAI API key, all within the same AI chat interface provided by JetBrains. This integration allows developers to leverage Codex's capabilities for delegating real coding tasks, with varying degrees of autonomy, from simple queries to more complex actions like accessing networks and running commands. Codex is initially available for free for a limited time when accessed via JetBrains AI, but after this period, its usage will consume AI Credits. The integration emphasizes flexibility, offering different authentication options and the ability to switch between OpenAI models for balancing reasoning depth, speed, and cost. JetBrains aims to enhance the developer experience by incorporating leading AI technologies directly into the IDE, making them accessible where developers work most efficiently.

IntelliJ IDEA Conf 2026 is a free, virtual conference designed for developers in the JVM ecosystem, taking place on March 26-27, 2026, featuring live technical sessions from experts at companies like JetBrains, Oracle, AWS, and Docker. The event will cover a wide range of topics related to Java and Kotlin development, including language evolution, enterprise Java, Spring applications, build tools, containerized workflows, JVM performance, and AI in development. Attendees can expect real-world insights and practical advice for professional projects, with opportunities for live interaction through Q&A sessions. All sessions will be streamed live and recorded for later access, allowing participants worldwide to engage at their convenience. Registration is open to everyone, offering flexibility to choose sessions of interest, and recordings will be available on the IntelliJ IDEA YouTube channel post-event.

Kotlin and Jakarta Persistence (JPA) together form a popular combination for server-side development, offering modern language features and a proven persistence framework. However, Jakarta Persistence was originally designed for Java, presenting challenges in aligning Kotlin's features such as null safety and data classes with JPA's specifications. The article outlines best practices for building reliable persistence layers in Kotlin, emphasizing the need for open classes, no-argument constructors, and mutable attributes to meet JPA's requirements. It discusses the limitations of using Kotlin's data classes for JPA entities and recommends using regular open classes to accommodate JPA's needs for proxy creation and lazy loading. It also highlights issues with Kotlin’s null safety and default values in the context of JPA, alongside practical solutions like using plugins to modify Kotlin’s default behaviors. The upcoming IntelliJ IDEA 2026.1 will aid developers by automatically detecting and highlighting potential issues, streamlining the process of integrating Kotlin with JPA.

The IntelliJ Platform has restructured its debugger architecture to support remote development, allowing the IDE to run locally while code executes on a remote server. This redesign splits the debugger into frontend and backend components, with the frontend handling the user interface and the backend managing active debugger sessions, enhancing responsiveness and stability in Remote Development mode. The changes necessitate updates for plugin developers, as older APIs related to debugger UI have been deprecated due to asynchronous UI creation, potentially causing race conditions. Developers are advised to test their plugins with the 2026.1 EAP, pay attention to IDE log error messages, and choose appropriate migration paths for Local or Remote Development modes. New APIs have been introduced to maintain compatibility and support additional functionality, requiring developers to adapt their implementations accordingly.

The latest TeamCity 2025.11.2 update introduces crucial bug fixes and enhancements for the TeamCity On-Premises platform, addressing issues such as UID changes for the "buildagent" user in Linux agent images, dark theme inconsistencies, and problems with artifact dependencies and the Agent Open Terminal button. This update also includes performance and security improvements, emphasizing the importance of staying current with minor releases to ensure better compatibility, faster builds, and enhanced security. With compatibility across all 2025.11.x releases, users can upgrade or downgrade without backup concerns, utilizing options such as the automatic update feature, direct downloads from JetBrains, or updated Docker images. For support, users are encouraged to engage with the TeamCity Forum or Issue Tracker.

Android Gradle Plugin (AGP) 9.0 introduces significant changes for Kotlin projects, requiring Android apps to adopt the built-in Kotlin support and Kotlin Multiplatform projects to migrate to a new Android KMP library plugin. This update eliminates the need for the separate Kotlin Android plugin, although projects using kapt or custom kotlinOptions will require additional configuration updates. A new Android KMP library plugin now replaces the previously used Android library and application plugins for multiplatform modules, necessitating migration of existing modules. While temporary opt-outs are possible, they will not be supported in AGP 10.0, expected in 2026. Developers are advised to update tools and plugins that rely on AGP and use the latest versions of Android Studio or IntelliJ IDEA for full compatibility. Comprehensive migration guides are available to facilitate these transitions, ensuring projects remain current with AGP developments.

The Scala 3.8 release introduces several new features and enhancements, including the "into" modifier, which simplifies type conversions by allowing types implicitly convertible to a declared type to be accepted without the need for an implicitConversions import. This release requires JDK 17 or newer, and the Scala plugin provides warnings if an older JDK version is selected. The "Better fors" feature offers a syntax relaxation for for-comprehensions, allowing aliases before a generator. Additionally, the release includes basic support for capture checking, which is still experimental, and introduces the runtimeChecked method to bypass certain static checks in the compiler, such as pattern match exhaustivity. The Scala team at JetBrains is committed to improving support for Scala 3.8 and encourages user feedback to enhance the development experience further.

TransformConf is a new conference scheduled for September 15–16, 2026, in London, UK, focusing on the transformative role of AI in software development. Organized by JetBrains, the event targets a diverse audience including developers, ML researchers, engineers, DevOps specialists, and technical leaders. The conference aims to facilitate practical discussions on building, deploying, and maintaining AI systems, aligning AI development across disciplines, and exploring advanced modeling and training techniques, among other topics. It will feature educational talks, peer discussions, and activities designed to provide immediate, actionable insights for attendees. TransformConf aspires to become a pivotal platform for conversations about AI's long-term impact on programming, developer productivity, and human-AI collaboration, while also addressing ethics and compliance issues. Early bird tickets are already available, and the call for speakers and partnership opportunities is open, providing a platform for innovation and community building in the AI-driven software development landscape.

Compose Hot Reload, now at its stable release of version 1.0.0, is a tool integrated with Compose Multiplatform starting from version 1.10, designed to facilitate the dynamic updating of applications during development with minimal user intervention. It allows developers to make changes to their code, recompile, and see these changes reflected in the UI without restarting the application, thanks to its integration with the JetBrains Runtime and DCEVM for dynamic class redefinition. The tool uses a combination of custom Java agents, bytecode analysis, and orchestration protocols to manage state and code updates efficiently, providing a seamless development experience. With features like a floating toolbar, in-app notifications, and IDE integration, developers receive real-time feedback and control over the reload process. Despite the complexities involved, including challenges with bytecode consistency and the limitations of the JetBrains Runtime, Compose Hot Reload successfully enhances the developer's workflow by offering intuitive and rapid UI updates.

CLion's upcoming release, version 2026.1, focuses on maintenance and bug fixes rather than introducing new features, with priorities set on enhancing language support, build tools and project formats, and features for embedded development. The update includes improvements to CLion's language engine, CLion Nova, and plans to integrate popular features from the legacy engine, along with support for Clang blocks and GCC nested functions. Enhancements in build tools involve better Bazel support and optimizing the update process, particularly for Windows users, while embedded development updates will refine features like live watches and introduce a dedicated OpenOCD debug server. Although the roadmap outlines significant plans, it remains preliminary, and the final implementation may vary due to unforeseen circumstances.

The fourth installment of the "Building AI Agents in Kotlin" series explores the use of sub-agents to enhance efficiency and reduce costs in AI agent development. The article discusses the implementation of a "find sub-agent" using tools provided by Koog, which aims to limit context growth and improve performance by using a simpler and cheaper LLM model, GPT4.1 Mini, instead of the main agent's model. Through a strategic division of tasks, developers can maintain or improve performance while achieving a 10% cost reduction per instance, as evidenced by benchmark results. The approach mirrors team structures in software engineering, suggesting potential benefits from task specialization, although this remains an unproven strategy. Ultimately, the article highlights the potential of sub-agents to achieve cost savings while maintaining performance, paving the way for further exploration of context management and compression techniques in future installments.

Compose Multiplatform 1.10.0 introduces significant advancements, including a unified @Preview annotation, support for Navigation 3 on non-Android targets, and a stable Compose Hot Reload feature, all aimed at enhancing the development experience across platforms. The update consolidates the previously separate @Preview annotations into one, simplifying the process for developers working in the commonMain source set. Navigation 3 offers a more straightforward way to manage navigation stacks with new usage patterns, while the Compose Hot Reload plugin now allows for immediate UI changes without restarting applications, bundled by default with the Compose Multiplatform Gradle plugin. This release also includes improved dependency management for Compose Multiplatform libraries and encourages users to consult detailed documentation and report any issues on the issue tracker.

The JetBrains Developer Ecosystem Survey 2025 offers a detailed examination of China's developer landscape, highlighting both global similarities and unique local traits. Java is particularly dominant in China, with 58.17% of developers using it as their primary language, contrasting with the global average of 27.76%. This is largely due to the country's booming internet industry and the widespread use of Java in mobile app development. The survey also reveals a high engagement with mini-apps, with 30.27% of Chinese developers involved in their development, and a growing prevalence of low-code/no-code platforms, used by 30% of respondents for building websites and applications. Moreover, the types of companies employing developers in China differ significantly from global patterns, with a higher percentage working for startups and publicly traded companies. In terms of AI tools, local alternatives like DeepSeek and TONGYI Lingma are preferred over global leaders, reflecting a trend of favoring domestic or self-hosted solutions. These insights aim to provide valuable perspectives for both local and international developers interested in understanding the nuances of the Chinese market.

TeamCity offers a comprehensive solution for overcoming the daily challenges associated with legacy CI/CD systems by providing built-in health signals and diagnostic tools that enhance pipeline visibility and efficiency. By offering clear insights into success rates, build duration trends, and bottleneck identification, TeamCity enables users to quickly address pipeline issues, reducing the time engineers spend troubleshooting and allowing them to focus on delivering high-quality software. The platform's Statistics Charts and analytic dashboards provide detailed insights into critical metrics such as success rates, test failures, and release velocity, helping teams maintain stable and fast pipelines while ensuring code quality. Additionally, TeamCity's tools for tracking code coverage and managing flaky tests support thorough quality assurance and help pinpoint the root causes of pipeline inefficiencies. With these features, TeamCity transforms the CI/CD process into a data-driven operation that enhances developer productivity and ensures timely, reliable software deployments.

John Arundel's guest post on the GoLand Blog explores the concept of "backwards programming" in Go, drawing an analogy to Ginger Rogers' ability to dance backwards. The approach involves writing tests before implementing the function, exemplified by creating a function to check if a given slice is sorted. Arundel humorously guides readers through the process, starting with intentional failures to ensure tests can catch bugs, gradually refining the function to pass all tests. This method emphasizes the importance of test-driven development, encouraging programmers to think critically and iteratively about their code. The narrative concludes with a suggestion to leverage Go's standard library for simplification, demonstrating how pre-written tests can provide a safety net for refactoring efforts.

Advent of Code 2025 in Kotlin was celebrated with a vibrant community spirit, featuring five days of livestreams where Sebastian Aigner and guests tackled puzzles using idiomatic Kotlin approaches. The event fostered collaborative problem-solving and community engagement through the #advent-of-code channel on Slack, where participants shared creative snippets, hints, and encouragement. The competition recognized nine winners across three categories: Fastest to Solve, Random, and Community, highlighting individuals for their speed, participation, and community contributions. The event continues to offer learning resources, including a YouTube playlist and tutorials, encouraging ongoing engagement with Kotlin and algorithmic challenges beyond the festive season.

JetBrains implemented a novel approach by integrating real users into their internal product team gatherings to bridge the gap between product assumptions and practical realities. The initiative involved two hands-on user workshops, one online and another in their Belgrade office, which allowed developers, designers, and managers to engage directly with users, fostering empathy and transforming feedback into tangible improvements. Despite challenges such as short recruitment timelines and logistical issues with rewards, the workshops succeeded in providing valuable insights into user interactions with their tool. The experience allowed team members to practice interviewing skills and grounded product discussions in real experiences rather than abstract reports, ultimately strengthening the connection between product development and user needs. The initiative highlighted the benefits of embedding user sessions into team gatherings, making feedback more tangible and enhancing empathy without requiring separate UX research processes.

Java Annotated Monthly's January 2026 edition kicks off the year with featured insights from Neha Sardana, a seasoned Java developer at Morgan Stanley, who shares her expertise in open-source software and Java's evolving landscape. The edition delves into Project Valhalla, which is set to revolutionize Java by optimizing memory usage and boosting performance through value types, offering a glimpse of the future alongside Project Loom. The newsletter also provides a roundup of Java news, highlighting the latest updates like the JEP 401 and JDK 26, while offering tutorials and tips for enhancing Java productivity. It touches on the intersection of Java and AI, exploring how these technologies are shaping the development landscape. The publication concludes with community news, conference announcements, and insights into Kotlin and Spring updates, encapsulating a comprehensive overview of current trends and innovations in the Java ecosystem.

dotInsights by JetBrains is a newsletter that provides updates on the latest developments in the .NET and software development community. It includes various topics such as sending messages with Google Pub/Sub, updates for .NET MAUI developers, and the use of Pulumi with C#. The newsletter also covers enterprise patterns for ASP.NET Core Minimal API, new features in C# 14 and .NET 10, and tips for writing AI-ready C# code. There are insights on reducing bugs using the Model View Update pattern, memory optimizations in .NET 10, and strategies for handling authentication schemes in C# Minimal API. Additionally, it features discussions on transitioning developers into leadership roles, advancements in JetBrains tools like Rider and ReSharper, and the introduction of the new Islands Theme in JetBrains IDEs.