July 2026 Summaries
64 posts from JetBrains
Filter
Month:
Year:
Post Summaries
Back to Blog
RevenueCat Shipaton 2026, the world's largest mobile hackathon running from August 1 to September 30, encourages developers with Kotlin knowledge to create cross-platform apps for a chance to win significant prizes. JetBrains, as a Gold Sponsor, introduces the "Ship Kotlin Everywhere Award," which incentivizes developers to build a new app using Kotlin Multiplatform and Compose Multiplatform, targeting platforms such as Android, iOS, desktop, and web. The award offers a $30,000 prize pool, with the first-place winner receiving additional perks, including a Times Square billboard feature and an invitation to RevenueCat’s App Growth Annual conference. Participants benefit from free access to IntelliJ IDEA Ultimate, an AI coding agent, and various guides and support, with all necessary resources available on the award page. Chris Krueger, a previous winner, highlights the advantages of using Kotlin Multiplatform for developing cross-platform applications, emphasizing the potential for growth and user reach.
Jul 31, 2026
464 words in the original blog post.
ReSharper, a popular extension for .NET development, has enhanced its capabilities in Visual Studio Code by integrating a built-in .NET debugger, which stems from the robust debugging engine of JetBrains Rider. This addition complements the existing suite of tools that include deep static code analysis and intelligent refactoring, aimed at preventing bugs before they reach the debugging stage. ReSharper's static analysis highlights inefficiencies and potential issues in real-time, offering over 2,500 inspections to guide developers in optimizing their code. The extension also provides a powerful rename refactoring feature, ensuring semantic safety by accurately updating references across projects without affecting unrelated strings or comments. With these tools, ReSharper creates a seamless, efficient, and comprehensive development environment for .NET developers, enhancing productivity by combining debugging, static inspections, navigation, and refactoring in a unified ecosystem within lightweight editors like Visual Studio Code.
Jul 30, 2026
1,338 words in the original blog post.
In this comprehensive tutorial by Naa Ashiorkor, the accessibility and practicality of using PyTorch, an open-source deep learning framework, for building and deploying AI models are explored. PyTorch, which evolved from Torch and was reinvented by Meta AI, has rapidly grown into a preferred framework in both research and industry due to its dynamic computation graphs, Pythonic interface, and strong GPU acceleration. The tutorial guides readers through creating their first PyTorch model using the MNIST dataset in PyCharm, illustrating how to build a neural network that recognizes handwritten digits. Key concepts such as tensors, model building with the torch.nn module, data preparation, training loops, and model evaluation are covered, emphasizing PyTorch’s intuitive design and debugging capabilities. With a 63% adoption rate in model training and widespread use in academia and industry, PyTorch is highlighted as a robust ecosystem for AI development. The tutorial concludes by encouraging further exploration of PyTorch’s advanced features such as GPU acceleration, distributed learning, and model deployment with TorchServe, providing readers with resources to continue their deep learning journey.
Jul 29, 2026
5,667 words in the original blog post.
Securing APIs is a critical but challenging aspect of API development, often targeted by malicious actors due to the exposure of data and functionality. OAuth 2.0 and JSON Web Tokens (JWT) are instrumental technologies in managing API security by facilitating identity representation, verification, and delegated authorization. This tutorial by Mdu Sibisi, an experienced software developer, explores how these technologies can be effectively implemented to secure APIs built with Spring Boot, illustrating the process with a Kotlin and Spring-based document management system. OAuth2 handles delegated authorization by allowing users to grant applications a token representing their permissions, while JWTs provide a compact, verifiable token format for secure information transport. The tutorial emphasizes separating authentication (identity verification) from authorization (access control) and highlights best practices like issuer and audience enforcement, custom claims mapping, and avoiding hardcoded security decisions. The approach leverages Kotlin's capabilities, such as null safety and concise configuration, to enhance security and reduce system complexity while maintaining usability.
Jul 29, 2026
3,063 words in the original blog post.
Qodana 2026.2 introduces enhancements that simplify code quality, security, and compliance checks within development workflows, featuring improved code coverage insights for pull requests and automatic detection of coverage reports in common project locations, reducing configuration requirements. The update broadens Qodana's security capabilities with new inspections, including post-quantum cryptography checks and custom security rules, while providing publicly available SAST benchmarks through SABER for transparency and evaluation. Laravel code inspections are now enabled by default, and new License Audit quality gates help manage dependencies with prohibited or unknown licenses. The release also supports advanced multi-file taint analysis and pattern-matching for detecting vulnerabilities, and it is designed to assist developers in preparing for future security risks associated with quantum computing.
Jul 29, 2026
1,558 words in the original blog post.
KotlinLLM is an open-source research prototype designed to integrate large language models (LLMs) into Kotlin/JVM projects through an IntelliJ IDEA plugin, introducing Smart macros as a new language feature. This tool allows developers to delegate runtime logic to LLMs by generating Kotlin code that updates as applications encounter new scenarios, without the need for direct LLM calls at runtime, thus avoiding latency and cost issues. The Smart macros, specifically asLlm and mockLlm, facilitate the conversion of unstructured data into typed Kotlin values and create stateful test doubles, respectively. KotlinLLM addresses the challenges of using LLMs in compiled, statically typed languages by providing a system that is explicit, persistent, and portable, ensuring that generated behavior is reviewable and distributable like regular code. The prototype has demonstrated feasibility in projects like an adapted Spring Petclinic and a GitHub issue parser, and it invites community feedback and contributions to refine its capabilities.
Jul 28, 2026
780 words in the original blog post.
The JetBrains State of CI/CD 2026 Survey is designed to capture the evolving landscape of continuous integration and continuous delivery (CI/CD) as AI-assisted development reshapes code creation, and organizations modernize their platforms and workflows. With input from software developers, DevOps engineers, platform engineers, and engineering leaders, the survey aims to provide insights into the most widely used CI/CD platforms, the impact of AI on software delivery, the modernization of CI/CD infrastructure, and the challenges facing DevOps and platform teams. Participants have the opportunity to win prizes such as a JetBrains All Products Pack subscription or Amazon gift cards, and the results will be shared on the TeamCity Blog later this year.
Jul 28, 2026
293 words in the original blog post.
The Ponytail skill for Claude Code, part of a series on "token saver" add-ons for coding agents, is designed to minimize code generation by AI agents. In a study involving 80 paired tasks, it achieved a 15% reduction in code written and a 10.3% reduction in cost, significantly less than its advertised 54% code reduction. The skill, which operates by prompting the AI to write minimal code only when necessary, was the first in the series to show a statistically solid cost-saving signal. The effectiveness of Ponytail is more pronounced in tasks with room for over-building, where it reached a 31% code reduction, whereas tasks that were already lean showed minimal change. While no differences in quality were detected, the study was not designed to prove equivalence, only to ensure that essential features like validation and error handling were not compromised. Ponytail's cost-saving results stand out compared to other tools in the series, such as the caveman skill and RTK, which did not achieve similar positive outcomes. However, Ponytail requires a specific installation method to function effectively, as it does not self-activate unless set up as a plugin with a SessionStart hook.
Jul 28, 2026
3,074 words in the original blog post.
TeamCity has released maintenance updates 2026.1.3 and 2025.11.7 for its On-Premises versions, primarily targeting security enhancements by addressing over 20 vulnerabilities each, including a critical CVE-2026-63077. The 2026.1.3 update also fixes functional issues like inconsistent test results during parallel test assembly execution, undetected Perforce child stream changes, and failures when uploading artifacts to Amazon S3. Users are strongly encouraged to upgrade promptly to benefit from performance improvements, better integration compatibility, faster builds, and enhanced security. The 2026.1.3 release is compatible with other 2026.1.x releases, allowing seamless upgrades or downgrades without the need for backup. Users can update via the automatic update feature, download from the JetBrains website, or pull the updated Docker image, and support is available through the TeamCity Forum or Issue Tracker.
Jul 27, 2026
296 words in the original blog post.
A critical security vulnerability identified as CVE-2026-63077 has been discovered in all versions of TeamCity On-Premises, which could allow an unauthenticated attacker to bypass authentication checks and execute arbitrary operating system commands. Users are advised to update to versions 2025.11.7 or 2026.1.3, where the issue has been resolved, or apply a security patch plugin if an update is not possible. This vulnerability, reported privately in July 2026, does not affect TeamCity Cloud customers, as they have already received the necessary measures. To mitigate risks, it's recommended to limit network access to trusted networks and run TeamCity servers with minimal privileges on dedicated hosts. There are currently no reports of this vulnerability being actively exploited.
Jul 27, 2026
769 words in the original blog post.
IntelliJ IDEA and Hibernate 7.4 offer distinct reverse engineering features for generating Java persistence artifacts from existing database schemas, each catering to different project needs. Hibernate 7.4 integrates reverse engineering into the build process, allowing for repeatable, automated generation of artifacts like JPA entity classes and schema SQL scripts using tools like Maven and Gradle, making it ideal for environments requiring consistent, version-controlled workflows that can be executed across various IDEs or CI/CD pipelines. In contrast, IntelliJ IDEA provides a more interactive and flexible approach, allowing developers to directly generate and synchronize JPA entities with evolving database schemas without losing manual customizations, which is particularly beneficial for projects needing incremental updates and visual integration within the IDE, although it requires an IntelliJ IDEA Ultimate subscription. Each tool has its strengths, with Hibernate 7.4 offering a robust solution for build-driven processes, while IntelliJ IDEA facilitates ongoing development and schema evolution in a more dynamic and user-friendly manner.
Jul 27, 2026
1,331 words in the original blog post.
C and C++ projects are increasingly being rewritten in Rust to enhance memory safety, reduce maintenance costs, and modernize performance-critical systems, with an emphasis on incremental migration strategies over full rewrites. This migration trend is driven by the growing confidence in Rust's ability to manage complex patterns, provide safety in concurrent systems, and reduce memory-safety vulnerabilities, as evidenced by companies like Google. Incremental migration allows teams to integrate Rust modules gradually within existing systems, thus maintaining operational stability and leveraging existing knowledge while progressively transitioning from C or C++. The process involves starting with isolated modules to resolve integration challenges, eventually leading to a more comprehensive adoption of Rust without disrupting the existing workflow. This approach is particularly suitable for performance-sensitive, concurrent, or security-critical codebases where maintainability is crucial, and the migration cost is justified by long-term benefits such as reduced defect rates and improved developer productivity.
Jul 27, 2026
2,042 words in the original blog post.
IntelliJ IDEA 2026.1 has introduced a new web-API-based IDE plugin generator, streamlining the process of creating IntelliJ Platform plugins by merging the strengths of the previous IDE plugin generator and the IntelliJ Platform Plugin Template. This new generator aims to simplify plugin development by reducing maintenance overhead, ensuring consistent and up-to-date templates, and providing a unified workflow with a single entry point accessible both through JetBrains IDEs and a web browser. The previous dual approach required updates in two separate places and created user confusion due to differing functionalities and integration options. The new generator offers consistent templates, automatic updates, and integration features such as GitHub workflows, issue templates, and Dependabot configuration, accessible via the IDE or a web UI. Future plans include adding new features like UI integration tests and Qodana setup to further enhance the plugin development process.
Jul 24, 2026
989 words in the original blog post.
JetBrains has released bug-fix updates for several major versions of MPS, specifically 2025.3.1, 2025.2.3, and 2025.1.3, addressing various issues to improve the software's performance. Notably, two significant fixes have been backported from the upcoming 2026.1 version: one involves applying a read-only property to all editor cells in the inspector, which makes the inspector read-only for the inspected node when a specific cell is selected, and the other corrects the height and spacing of items in the Help menu on macOS. Users can download these updates and view the complete list of fixed issues for each version to ensure their systems are up-to-date.
Jul 24, 2026
185 words in the original blog post.
Code coverage is a critical software testing metric that measures the percentage of source code executed by automated tests, impacting software quality and deployment confidence. It involves understanding various metrics such as line, branch, condition, and path coverage, with tools like JaCoCo, Istanbul/NYC, and Coverage.py often employed to generate reports within CI pipelines. While aiming for 80% coverage is a common industry standard for critical business logic, achieving 100% is often impractical and might not correlate with reduced post-release defects. Improving code coverage focuses on identifying untested code, especially in high-risk areas, and integrating coverage checks into CI/CD workflows. However, high code coverage can provide a false sense of security if tests lack meaningful assertions, and coverage should be complemented with static code analysis for a comprehensive view of code health. In safety-critical domains, near-100% coverage can be mandated, but for most projects, balancing test quality and risk is more crucial than chasing perfect coverage metrics.
Jul 23, 2026
2,811 words in the original blog post.
RustRover 2026.2 introduces enhanced support for Axum, a popular web framework in the Rust ecosystem, aimed at streamlining the development of web services, APIs, and distributed systems. Axum's popularity stems from its ergonomic design, modular architecture, and integration with the Tokio async runtime, making it suitable for high-stakes applications like infrastructure APIs and security-sensitive services. The updated IDE simplifies navigating routes, understanding request flows, and generating client calls, with features like URL resolution, endpoint discovery, and Reqwest request generation. Axum's robust adoption is evident in its use by projects such as the Rust package registry, crates.io, and Cloudflare Workers, and it serves as a foundation for several Rust web stacks. RustRover's new capabilities aim to improve developer efficiency by offering a seamless experience in handling Axum routes and Reqwest calls, while continuing to evolve based on user feedback and contributions from the Rust community.
Jul 23, 2026
1,078 words in the original blog post.
CLion has advanced its transition to the Nova engine as the default for C and C++ development, with the Classic engine now available only as an optional plugin in the CLion 2026.2 release. Users who have already made the switch to Nova need not take any action, while those still relying on the Classic engine can access it via the C/C++ Language Support plugin from the JetBrains Marketplace. The transition timeline indicates that the last stable release of the Classic engine will be compatible with CLion 2026.3 in November 2026, with updates ceasing afterward. Users needing assistance transitioning to Nova can reach out to their customer success engineer, account manager, or use the enterprise customer contact form for support.
Jul 22, 2026
274 words in the original blog post.
RustRover 2026.2 introduces numerous enhancements for Rust developers, including endpoint discovery and route-handler navigation for axum projects, as well as support for the Ferrocene toolchain. The update improves the development experience with features like an interactive macro tester that helps developers understand the expansion of declarative macros, smarter import cleanup, and local variable completion for struct literals. It also offers new productivity tools, such as Criterion benchmark run configurations and improved split mode for remote development. Additionally, the release enhances .env file support, making environment variable management more seamless, and simplifies copying fully qualified Rust paths. In terms of AI integration, it introduces an Agent skills manager to retain domain knowledge across projects and sessions, allows connection of third-party AI model providers for code completion, and integrates GitHub Copilot directly into the IDE for a more cohesive experience.
Jul 22, 2026
1,021 words in the original blog post.
ReSharper C++ 2026.2 introduces significant advancements, including support for C++26 reflection, which allows compile-time introspection and code generation, though currently only supported by GCC 16. This release enhances the constexpr evaluator to handle dynamic memory allocation and constexpr exceptions, while also introducing consteval blocks and user-defined annotations for improved metaprogramming. Additionally, the update brings ISPC language support for high-performance parallel programming, particularly benefiting Unreal Engine projects with faster indexing and enhanced Blueprint support. New code inspections and refactoring tools, such as improved inline function usage and context actions for toggling const qualifiers, further streamline coding practices, and the release also emphasizes performance improvements in Unreal Engine projects, making startup and indexing significantly faster.
Jul 22, 2026
1,112 words in the original blog post.
ReSharper 2026.2 introduces significant updates and enhancements, focusing on AI integration and improved developer tools for .NET within Visual Studio and VS Code-compatible editors. This release marks the beginning of an open AI ecosystem through the introduction of the Agent Client Protocol (ACP), allowing developers the freedom to choose from various AI agents and models without vendor lock-in. The new AI agent, Junie, is introduced in preview mode, enabling code writing, refactoring, and Git management directly from Visual Studio. The update also extends ReSharper's debugging capabilities to VS Code editors, enhances C# analysis and refactoring features, and introduces initial support for C++26 reflection. Other highlights include integrated profiling and coverage tools and improved performance for processing .cshtml and .razor files. JetBrains emphasizes the coexistence of AI-assisted workflows with traditional coding routines, aiming for a seamless development experience.
Jul 22, 2026
1,241 words in the original blog post.
Rider 2026.2 introduces significant enhancements to JetBrains' IDE, focusing on integrating AI agents to leverage the IDE's intelligence for coding tasks, improving performance, and updating game development features. This release integrates GitHub Copilot as a native AI agent, enhancing AI-driven coding support, and allows users to connect third-party completion models. Performance improvements include faster debugger launches for .NET apps and improved C++ indexing for Unreal Engine projects. Game development advancements feature enhanced AI agent skills tailored for Unreal Engine and Godot, alongside improved debugging capabilities across platforms. Rider 2026.2 also expands language support with updates for C#, C++, and F#, and introduces new tools like Hot Reload for WPF, file-based C# app templates, and built-in Azure Functions support, aiming to streamline development workflows and enhance productivity.
Jul 22, 2026
1,111 words in the original blog post.
JetBrains' Q2 2026 newsletter for plugin developers offers a comprehensive update on IntelliJ Platform Marketplace, highlighting new features and improvements aimed at enhancing plugin stability and development efficiency. Key updates include automatic notifications for plugin authors using internal APIs, a default-enabled Exceptions tab for tracking production issues, and enhancements in plugin development tooling such as the IntelliJ Platform Plugin Template, Plugin Verifier, and Gradle Plugin. The newsletter also provides practical tips for optimizing plugin distribution size and promotes resources for adapting plugins to remote development environments, improving UI responsiveness, and enhancing accessibility in JetBrains IDEs. Additionally, it introduces the open-sourcing of the LSP Client API for IntelliJ IDEA 2026.2, offering developers broader access to a battle-tested API across various JetBrains products. The community spotlight section showcases practical demonstrations on building modular plugins and implementing secure authentication flows for JetBrains IDE plugins.
Jul 21, 2026
838 words in the original blog post.
RubyMine 2026.2 introduces several innovative features and enhancements, notably agentic debugging and native GitHub Copilot integration, which streamline the debugging process and facilitate code assistance through AI. The release improves AI-based code completion by allowing integration with third-party providers, while the default activation of symbol-based code insight enhances navigation and documentation accuracy. The update also focuses on enriching the user experience with faster gem environment updates, simpler project setup, and more efficient RuboCop processing. Enhancements in the Ruby ecosystem include better support for RBS and expanded compatibility with RSpec 4, ensuring smoother transitions for existing projects. With improved handling of partially resolved code and clearer Quick Documentation, RubyMine 2026.2 aims to optimize development workflows, making it easier for developers to focus on their code.
Jul 21, 2026
813 words in the original blog post.
JetBrains has introduced JetBrains Context, a repository intelligence layer designed to enhance the efficiency and output quality of coding agents working with complex codebases. Available at no extra cost to JetBrains AI subscribers, this tool integrates with several coding agents and can be used with a variety of IDEs and editors. By providing a semantic index of repositories, JetBrains Context allows agents to access relevant information quickly, reducing the need for repetitive file searches and manual code exploration. This advancement addresses the growing demand for efficient AI usage as developers face increased expectations and pressure to deliver results with limited resources. JetBrains Context supports multi-repo searches, enabling agents to discover code across entire organizations, thereby improving code quality and maintaining architectural consistency. Initial evaluations demonstrated significant reductions in agent turns, latency, and execution costs, highlighting its potential to streamline coding processes in large-scale projects. Users can set up and utilize JetBrains Context through a simple installation process, and feedback is encouraged to refine the tool further.
Jul 21, 2026
981 words in the original blog post.
The latest release of JetBrains Air introduces several new features, including support for GitHub Copilot and other ACP-compatible agents, enhanced Java and Kotlin code intelligence, and the ability to run Windows tasks in Docker containers. Air enables developers to connect their own coding agents and harnesses, allowing tasks to be executed in parallel workspaces and reviewed before integration into the codebase. This update also allows companies to use their approved coding tools, such as GitHub Copilot, without needing additional AI providers. Local model support has been added, facilitating the use of models running offline via local runners like Ollama or LM Studio. With IntelliJ-powered navigation, users can now efficiently manage Java and Kotlin projects, identify errors, and inspect code changes directly within Air. The inclusion of Docker containers for Windows aligns with macOS capabilities, enabling isolated task execution. The update also focuses on giving users more control during agent runs, including reviewing proposed changes and monitoring context-window usage. Overall, these enhancements aim to improve the flexibility, control, and efficiency of AI-assisted coding workflows in JetBrains Air.
Jul 21, 2026
907 words in the original blog post.
PyCharm 2026.2 introduces several enhancements aimed at improving Python development efficiency and flexibility, including the integration of a new Rust plugin for building Python extensions and the debugpy engine as the default debugger. This release streamlines external utility management through a redesigned settings UI for uvx and supports multi-project setups for uv, Poetry, and Hatch workspaces. Notable features include an editor minimap for easier navigation of complex files, the integration of the Pyrefly engine for faster type insights, and AI-driven project generation for users with a JetBrains AI license. Additionally, an agent skills manager facilitates the retention and application of domain knowledge across projects, enhancing the utility of AI agents within the IDE.
Jul 21, 2026
432 words in the original blog post.
The "Rust Token Killer" (rtk) was tested to evaluate its claims of reducing token usage by 60-90% for coding agents. The results showed that instead of saving tokens, rtk led to a 7.6% increase in costs at low reasoning effort and no significant savings at high effort. The tool works by intercepting shell commands and providing compressed output to the model, but it only interacts with a small fraction of the agent's activities, as many tasks use built-in tools that bypass the Bash hook. Additionally, the compression did not compromise task quality, although it occasionally caused minor increases in processing time due to extra explorations or broken rewrites. Despite the appealing concept and effective operation of rtk, its self-reported savings misrepresent actual financial outcomes, as the tool's counterfactual assumptions do not align with the real-world billing scenario.
Jul 20, 2026
1,995 words in the original blog post.
Escape analysis in Go is a compiler optimization technique that determines whether a value should be allocated on the stack or the heap, which is crucial for managing memory efficiently. The stack offers cheaper and faster allocations that are automatically reclaimed when a function returns, whereas heap allocations are more resource-intensive and require garbage collection. This process is automatic, but understanding escape analysis can help developers optimize performance, particularly in hot paths or latency-sensitive workflows. Common reasons for values escaping to the heap include returning pointers, closures, goroutines, and storing values in structures that outlive the current function. Although escape analysis is typically hidden behind compiler flags, tools like GoLand simplify its usage by providing intuitive interfaces that integrate directly into the code editor, helping developers to focus on meaningful optimizations without disrupting workflow. While heap allocations are normal and often necessary, analyzing escape patterns can aid in reducing unnecessary allocations, thereby improving application performance, but only where it truly matters.
Jul 20, 2026
3,330 words in the original blog post.
JetBrains has been recognized in the 2026 Gartner® Magic Quadrant™ for DevOps Platforms for their ability to execute and completeness of vision, emphasizing the importance of focusing on environments developers frequently interact with, rather than rushing to adopt every new AI trend. In the crowded DevOps landscape, JetBrains prioritizes deterministic code intelligence to maintain developer control and accountability amid increasing complexity from AI-generated code. The company’s solutions, such as Qodana, TeamCity, and YouTrack, are designed to enhance code quality, CI/CD processes, and project management while advocating for an open ecosystem that allows developers to integrate top models and agents without sacrificing their preferred engineering features. JetBrains continues to innovate with tools like JetBrains Central, Air, and Junie CLI, aiming to provide a seamless and powerful user experience that adapts to the evolving AI-driven software development landscape. Despite their recognition, JetBrains and Gartner both emphasize that Gartner’s research does not constitute an endorsement, and it remains crucial for users to evaluate vendors and their offerings independently.
Jul 20, 2026
771 words in the original blog post.
PhpStorm 2026.2 introduces several enhancements focusing on AI integration, PHP and Laravel support, Git management, and overall productivity improvements. The release includes native support for more third-party AI providers, allowing agents to access IDE features and manage skills across projects. GitHub Copilot is now natively integrated, simplifying AI-based code completion and enhancing the coding experience. PhpStorm adds new PHP features like the #[FileReference] attribute for persistent file path references and support for PHP 8.5's pipe operator. Laravel developers benefit from a new tool window to manage projects and improved package support. The update also incorporates TypeScript 7 for faster performance, enhances Git worktree management, streamlines conflict resolution, and adds terminal improvements for file and image sharing. The database management experience is refined with a redesigned empty state, customizable query console names, and an adaptive color engine. Performance optimizations focus on reducing startup and indexing times, while Docker Compose integration sees improvements for easier configuration and monitoring.
Jul 17, 2026
1,866 words in the original blog post.
PHPverse 2026 brought together PHP developers from diverse backgrounds in a five-hour live-streamed event, attracting 15,000 views and over 10,000 live chat comments. The event featured talks from experts addressing common challenges in the PHP ecosystem, such as integrating AI agents, tackling new security threats, and fostering community involvement. Highlights included Fabien Potencier's insights on maintaining Symfony with AI agents, Ashley Hindle's experience with AI-generated code, and Jonathan Bossenger debunking myths about modern WordPress. Nils Adermann discussed enhanced security measures for Composer dependencies, while Jeffrey Way explored AI's impact on the programming world. Mike Herchel showcased modern Drupal's advancements, Larry Garfield explained the PHP RFC process, and Elizabeth Barron outlined The PHP Foundation's plans to sustain PHP. The event underscored the importance of innovation and collaboration in the PHP community and encouraged ongoing participation in its development and future events.
Jul 17, 2026
1,964 words in the original blog post.
Kotlin is celebrating its 15th anniversary, marking a significant milestone in its journey as a programming language. Over the years, the Kotlin community has played a vital role in shaping the language through building applications, contributing to its ecosystem, and sharing knowledge. To commemorate this occasion, enthusiasts are encouraged to participate in various celebratory activities, such as creating digital birthday postcards with wishes or predictions for Kotlin's future, and sharing them with the community. Additionally, there are opportunities to explore Kotlin's impact beyond coding, including playing browser games and accessing free Kotlin courses on Hyperskill until September 2026. The anniversary acknowledges the contributions and support from the community, emphasizing that there is still much more potential to unlock and ideas to explore with Kotlin.
Jul 17, 2026
250 words in the original blog post.
Advancements in artificial intelligence (AI) and extended reality (XR) are reshaping technological interactions, potentially marking a significant shift since the mouse-and-windowing paradigm of the 1970s and 80s. AI now introduces a conversational format to software engineering, while XR provides a rich input surface through gaze, hands, voice, and more, offering a multimodal human-AI experience. JetBrains Research's Human-AI eXperience (HAX) team explores these impacts on tech creators, such as software engineers and designers, through expert interviews. Their findings reveal the potential of AI-XR to address tech creators’ needs, the constraints of developing such tools, and the dissolution of boundaries between authoring, coding, and designing. While consumer-grade XR hardware and sensors are rapidly advancing, leading to more reliable tracking and diverse form factors, the field still seeks a new interaction paradigm suitable for spatial computing. Ethical concerns, technology readiness, and cognitive challenges are pivotal in developing AI-XR systems that are acceptable, safe, and humane, as they increasingly integrate into professional environments and everyday life.
Jul 16, 2026
4,049 words in the original blog post.
WebStorm 2026.2 introduces significant updates aimed at enhancing performance and usability for developers working with large TypeScript codebases, offering native TypeScript 7 support, which delivers faster type checking and improved editor responsiveness without necessitating a full project migration. This release also integrates GitHub Copilot directly into the IDE, allowing for seamless AI-powered development without additional setups, alongside a new agent skills manager that retains reusable knowledge across projects. Developers can benefit from full React 19 support in React Buddy, updated bundled language servers for frameworks like Astro, Prisma, Angular, and Vue, and enhanced Svelte support. Numerous quality-of-life improvements in debugging, testing, and user experience are included, such as better handling of Node.js workflows, refined style sheet support, and more stable test execution with Cypress and Playwright. The release also addresses performance and stability issues, optimizing memory usage and search performance while enhancing the overall user experience with features like customizable keymaps and improved Git worktree support.
Jul 16, 2026
1,161 words in the original blog post.
IntelliJ IDEA 2026.2 introduces over 1,300 bug fixes and usability improvements, with a focus on enhancing performance and responsiveness by addressing 140 freezes and performance issues identified through diagnostics and user reports. Key updates include asynchronous file saves to prevent UI freezes, improved navigation and usability in large or remote directory structures, and enhanced handling of Spring configuration metadata to reduce memory consumption and stabilize performance. The release also brings advancements in code resolution, navigation, and usage detection, particularly for Spring Boot, Spring Security, Spring Cache, and Spring Events, alongside enriched support for Thymeleaf and better integration for Kotlin in server-side projects. The Markdown editor now supports standard footnotes, and user interface enhancements have been made, such as persistent bookmark management across Git branches and improved plugin search functionality. The Machine Learning Code Completion plugin is deprecated due to the rise of AI-assisted coding tools, while the Task Management and Time Tracking plugins have been unbundled to streamline the installation, though they remain available via JetBrains Marketplace. Users are encouraged to provide feedback on these updates to guide future developments.
Jul 16, 2026
1,263 words in the original blog post.
IntelliJ IDEA 2026.2 introduces a range of updates aimed at optimizing workflows and embracing the latest Java ecosystem innovations, including support for Java 27 and Kotlin 2.4. This release enhances Spring development with improved database migration workflows and Spring Security insights, while also bolstering debugging with new logpoints and better navigation from runtime outputs to source code. Notable features include AI upgrades with native GitHub Copilot integration, productivity enhancements like logpoints and early Gradle 10 support, as well as improved Docker Compose and Git conflict resolution workflows. The update also offers support for new technologies, such as Terraform testing frameworks and TypeScript 7.0, alongside general stability, performance, and usability improvements, encouraging users to provide feedback to further refine the platform.
Jul 16, 2026
340 words in the original blog post.
CLion 2026.2, the latest release of JetBrains' IDE for C and C++, introduces a range of features aimed at enhancing the debugging and development experience. Key updates include a new debugger skill for AI agents, which allows autonomous investigation of issues, and support for STM32 Cube CLI, simplifying embedded development by managing specific tool downloads. The update also brings improved support for C++26 reflection, enabling compile-time access to code information, and simplifies debugger configurations with the introduction of debug profiles. Additional enhancements include support for Natvis on macOS and Linux, refined Bazel and CMake integration, improved Git conflict resolution, and terminal drag-and-drop functionality. The IDE now defaults to the CLion Nova engine, with the legacy CLion Classic engine available only as a plugin, and encourages user feedback to further refine the platform.
Jul 16, 2026
1,866 words in the original blog post.
GoLand 2026.2 offers a range of new features aimed at enhancing the development workflow for Go applications, with a particular focus on performance optimization and AI integration. The release introduces a Go Optimization tool window, which consolidates profiling, escape analysis, and struct optimization into a single workflow, allowing developers to analyze CPU and memory usage in real-time and optimize code without leaving the IDE. The update also integrates with the official go fix tool to streamline code modernization and includes improvements for Docker Compose and Terraform support, enhancing productivity in application and infrastructure workflows. AI capabilities have been expanded with a new agent skills manager, configurable AI completion models, and GitHub Copilot integration, providing more flexibility in using AI-powered tools. Additionally, the IDE has improved performance and responsiveness, particularly in handling large projects and file operations, and offers automatic creation of run/debug configurations to expedite the setup of new projects.
Jul 16, 2026
1,765 words in the original blog post.
DataGrip 2026.2 introduces a range of enhancements, focusing on AI integration, improved connectivity, and user interface improvements. The update adds three AI agent skills that facilitate database management tasks, including configuring connections and generating SQL from schema, supported by new MCP tools for managing data sources. It offers enhanced session control modes, a redesigned Welcome screen, and an interactive onboarding tour to streamline user experience. The release also provides bundled JDBC drivers and new CLI commands for data source management, allowing batch processing of actions. Improvements in database exploration include a revamped UI for schema attachments and a new color system for better organization of database objects. Additionally, the update enhances support for SQL expressions and query console features, making the workflows more efficient and user-friendly. The update is rounded out with expanded support for ClickHouse and Snowflake SQL, enabling better performance and functionality for users working with these platforms.
Jul 16, 2026
1,460 words in the original blog post.
JetBrains GameDev Day, set for September 28, 2026, is a free, live online event aimed at fostering knowledge exchange within the game development community by inviting speakers to share their experiences, tools, and insights. The event, which covers a wide range of topics including engine internals, CI/CD pipelines, AI in game development, and collaboration among diverse development teams, welcomes talks that are practical, technical, or experience-driven. Participants can present in various session formats, and their talks will be streamed live, recorded, and promoted by JetBrains. The event also includes community watch parties, with an offline presence planned at JetBrains' Limassol office and a special collaboration with DevGAMM in Belgrade, offering an opportunity for both global and local interaction. The call for speakers is open until August 12, 2026, and JetBrains encourages potential speakers to submit their proposals, with support available for shaping their ideas into comprehensive talks.
Jul 15, 2026
705 words in the original blog post.
The ReSharper 2026.2 Release Candidate introduces a range of enhancements aimed at improving the development experience in Visual Studio, with significant upgrades to C# and C++ development tools. This release marks the initial phase of ACP-based agent support with JetBrains' own agent, Junie, and offers improved C# analysis, including better handling of collection expressions and an enhanced Extract Method feature. Integration with .editorconfig and Roslyn analyzers is improved, allowing for easier adjustment of compiler warnings. The update also includes a revamped Import Missing References popup, alongside advancements in C++ including C++26 reflection and ISPC support. The processing of .cshtml and .razor files has become more efficient, while dotTrace, dotMemory, and Monitoring now operate in Out-of-Process mode. Users are encouraged to try the Release Candidate and provide feedback through YouTrack or social media platforms.
Jul 15, 2026
294 words in the original blog post.
The Rider 2026.2 Release Candidate introduces significant improvements to enhance both .NET and game development, integrating AI capabilities and offering native support for GitHub Copilot. This release focuses on performance enhancements, such as faster debugger launches and branch switching, and improved Unreal Engine indexing. Additionally, it expands game development support with new project templates and professional Godot tooling, including a configurable GDScript formatter and the official Rider integration addon. The release also features faster workflows for large TypeScript codebases, built-in Azure Functions support, and Azure DevOps pull requests, alongside a redesigned NuGet tool window and intention previews for quick fixes. The update encourages users to download, explore the new features, and provide feedback through YouTrack or social media.
Jul 15, 2026
408 words in the original blog post.
The MPS 2026.1 release introduces a variety of significant updates and enhancements for developers and language authors. Now built on the IntelliJ Platform 2026.1 with JDK 25 and Kotlin 2.3, this version enhances the Build Language with transitive dependencies and improves reproducibility in migrations. A major highlight is the inclusion of the Projectional Agent Toolkit, which allows AI coding agents to interact directly with MPS models, facilitating advanced development concepts. This toolkit supports AI agents like OpenAI Codex and JetBrains Junie, enabling them to navigate, edit, and generate code within MPS projects. Also notable is the integration of IntelliJ Platform’s natural language support, allowing capitalization checks in specific languages, and the introduction of a new read-only-inspector editor style. The update also refines the project lifecycle management and modernizes migration processes to ensure consistent dependency management. Additionally, users are encouraged to transition to a new UI as the Classic UI plugin is now disabled by default.
Jul 14, 2026
1,282 words in the original blog post.
ReSharper's latest 2026.2 release introduces significant enhancements for .NET developers using VS Code-compatible editors, including the long-awaited debugging feature. Built on JetBrains Rider's core debugging engine, this feature allows users to set breakpoints, inspect variables in real time, and manage .NET processes directly within their editor. Additionally, the update introduces value tracking, offering a live visualization of data flow to aid in resolving issues like NullReferenceException without launching a debugger. Navigation improvements, such as enhanced Call Hierarchy and Type Hierarchy views, simplify tracing method invocations and class inheritance. Project structure enhancements include inline NuGet package versions, prioritized service folders, and a streamlined method for integrating existing projects. These updates aim to enhance the efficiency and ease of .NET development across various compatible editors, inviting user feedback to further refine the tool.
Jul 13, 2026
660 words in the original blog post.
The introduction of debugging support in the ReSharper extension for .NET development in VS Code-compatible editors marks a significant enhancement, addressing a long-standing request from users. This feature, released in version 2026.2, leverages the same core debugging engine as JetBrains Rider, bringing comprehensive debugging capabilities to environments like VS Code, Cursor, Google Antigravity IDE, Devin Desktop, and Kiro. This development allows users to manage breakpoints, inspect variables and expressions in real-time, and execute full step navigation, all within their preferred editor, effectively eliminating the need for separate IDEs for debugging. Additionally, ReSharper's integration provides seamless configuration and migration support, automatically creating debugger configurations and supporting manual setup through templates. Although VS Code permits only one extension for C# debugging, users can opt for ReSharper by disabling other extensions. The update invites feedback from the community to further refine and enhance the debugging experience.
Jul 13, 2026
883 words in the original blog post.
JetBrains' dotInsights newsletter covers an array of updates and insights within the .NET and broader software development community, highlighting new tools, advancements, and practices. Key topics include the introduction of a new Visual Studio Solution File Format, the announcement of Epic Games' open-source Lore Version Control System, and advancements in C# and .NET 11, such as discriminated unions. The newsletter also discusses JetBrains' forthcoming Rider 2026.2 release, which promises improvements like cleaner async call stacks and new AI agent skills. Additionally, it mentions the integration of GitHub Copilot with JetBrains' AI Assistant, eliminating the need for a separate subscription, and emphasizes JetBrains' AI agent Junie's top ranking in the SWE-Rebench benchmark. The newsletter rounds off with updates on TeamCity's CI/CD vision and engages readers with a playful question about communication efficiency.
Jul 10, 2026
760 words in the original blog post.
JetBrains' Kotlin team embarked on a journey to create a mascot named Kodee, aiming to enhance the programming language's community connection with a character that embodies warmth, personality, and approachability. The process involved a collaborative effort among the Kotlin Marketing, Design, and Strategic Research teams, engaging the developer community through surveys, focus groups, and feedback sessions to refine the mascot's design and personality. Initially, Kodee's robotic character faced mixed reactions, leading to revisions that incorporated community feedback emphasizing friendliness, tech-savviness, and playfulness. The finalized mascot, Kodee, emerged as a beloved icon within the Kotlin ecosystem, celebrated for its expressive design and capacity to bridge creative communities beyond developers, as evidenced by its reception at the Pictoplasma conference in Berlin. This evolution from concept to community symbol reflects a successful integration of research, creativity, and collaboration, solidifying Kodee's role as more than a mascot but a symbol of Kotlin's inclusive culture.
Jul 09, 2026
2,176 words in the original blog post.
JetBrains Academy's June Digest highlights various opportunities and resources for developers to enhance their skills and showcase their expertise. It introduces a feature for connecting JetBrains IDE to LinkedIn, allowing users to display their coding activity on their profiles for more authentic visibility. The digest also announces a JetBrains Academy Discord Challenge where participants can build a local AI assistant using LLMs, with a chance to win prizes. Developers can explore a free Udemy course on working with real projects in IntelliJ IDEA to gain hands-on experience, while a new Coursera course offers a step-by-step guide to creating a local AI agent. Additionally, the Hyperskill platform provides a course on building Python-based AI agents, and a new YouTube video examines the effects of AI tutors on novice programmers, offering insights and advice for enhancing the learning process.
Jul 09, 2026
463 words in the original blog post.
The Kotlin Benchmark, released by JetBrains, is a new evaluation framework designed to assess AI coding agents on Kotlin software engineering tasks, offering a more realistic measure of their performance in end-to-end tasks, from issue reading to solution validation. This benchmark aims to provide a credible, public means for developers to evaluate and compare different AI coding agents on tasks sourced from active open-source repositories, focusing on repository-level challenges and requiring agents to navigate project contexts to generate functional solutions. The initial iteration of the benchmark, which is based on the SWE-bench methodology, features 105 tasks, with the top-performing AI agent, Claude Code with Opus 4.7 xhigh, resolving 85.71% of them. JetBrains plans to expand the benchmark to include broader Kotlin ecosystem coverage, additional evaluation metrics, and more agent and model setups, thereby offering a continuous quality measurement pipeline for AI coding agents. The benchmark is built on the open-source Multi-SWE-bench infrastructure, and all datasets and test harnesses are publicly available, allowing for community engagement and feedback.
Jul 08, 2026
670 words in the original blog post.
Shift-left static code analysis is a strategy in software development that emphasizes conducting testing, quality assurance, and security checks earlier in the software development lifecycle to identify and address issues as soon as possible. This approach involves automating testing processes, fostering continuous feedback, and encouraging developer ownership of code quality and security. By integrating tools like static code analysis into development workflows, teams can detect vulnerabilities and quality issues during the coding phase, which minimizes the need for context-switching and extensive rework later in the process. While implementing a shift-left strategy can present challenges such as false positives and integration friction, its benefits include faster feedback loops, reduced technical debt, improved code quality, and significant cost savings by catching defects early. This method does not eliminate traditional testing but enhances its effectiveness by ensuring that code has already undergone multiple reviews before reaching late-stage quality assurance.
Jul 07, 2026
1,670 words in the original blog post.
The July 2026 edition of Java Annotated Monthly, curated by Irina Mariasova, offers a comprehensive roundup of the latest developments in the Java and Kotlin ecosystems, AI advancements, and notable technological trends. Highlights include Tom Cools' insights on optimizing complex problems with Timefold Solver 2.0, Felienne Hermans' keynote on cognitive programming from J-Spring, and Holly Cummins' revelations on benchmarking pitfalls. The edition also covers significant Java updates like the integration of JEP 401 into OpenJDK, tutorials on AI-enhanced Java applications, and the progress of Kotlin, now celebrating its 15th anniversary. Additionally, it explores AI's intersection with software development, offering numerous articles on AI-powered tools, frameworks, and security. Upcoming events such as WeAreDevelopers in Berlin and JConf Dominicana are spotlighted, alongside cultural discussions on platform engineering and data-driven conversations in tech. The issue concludes with updates from JetBrains and invites reader contributions for future editions.
Jul 07, 2026
1,385 words in the original blog post.
TeamCity, a CI/CD platform by JetBrains, is evolving to address the growing integration of AI agents in software development, focusing on enhancing productivity, quality, and security. With the rise of AI-generated code, the demand for scalable, reliable, and secure CI/CD systems has intensified. TeamCity is enhancing its core features to support higher volumes of code changes and verification processes, while also developing new user scenarios to facilitate AI and human collaboration. The platform provides low-friction build configuration, faster investigation of build failures, efficient resource usage, and comprehensive visibility across the CI/CD system. JetBrains is also introducing AI governance capabilities through JetBrains Central, aiming to give organizations control, transparency, and policy enforcement over AI usage. The roadmap for TeamCity includes improving scalability, performance, and flexibility, along with expanding support for AI agents and integrations with other JetBrains products, to ensure secure and efficient software delivery in an increasingly AI-driven development landscape.
Jul 07, 2026
1,575 words in the original blog post.
JetBrains is launching a new set of AI capabilities aimed at enhancing software development for teams and organizations by providing shared context, reusable workflows, and organization-level governance while maintaining cost control. This initiative addresses the fragmentation caused by individual developers using different AI tools, such as JetBrains IDEs, Claude Code, and Codex, by introducing a vendor-agnostic platform that connects these tools with centralized management through JetBrains Central. The rollout, starting in July, will include features like team automations, cloud agents, and JetBrains Context for improved repository intelligence, while transitioning from AI licenses to flexible AI credits for a more transparent pricing model. The goal is to facilitate scalable AI adoption that balances developer flexibility with organizational oversight, enabling engineering teams to operate efficiently without being confined to a single tool or workflow.
Jul 07, 2026
888 words in the original blog post.
The research examined the reliability of coding benchmarks in assessing the capabilities of AI models, revealing a "meaning gap" between benchmark scores and actual performance across different coding tasks. Often, models show significant improvements on benchmarks they are specifically trained for, such as SWE-bench, but these gains do not necessarily translate to broader coding abilities or performance on other benchmarks like LiveCodeBench. The study suggests that current benchmarks mainly measure task-specific performance rather than general coding capability, leading to a distorted perception of a model's overall performance. The research highlights the need for more comprehensive benchmark suites and proposes solutions for better evaluation to bridge the meaning gap, urging the AI community to prioritize diverse and real-world evaluations over reliance on single benchmark scores.
Jul 07, 2026
3,148 words in the original blog post.
Object detection is a crucial component of various applications, ranging from autonomous vehicles and security systems to medical imaging and retail analytics. In 2026, selecting the right object detection model involves evaluating different architectures, performance metrics, and use cases. Object detection requires identifying and localizing multiple objects within images or video frames, which is more complex than mere classification. Key performance metrics include mean average precision (mAP) and compute efficiency metrics like frames per second (FPS). The COCO dataset is a standard benchmark for evaluating object detection models. Models are built on CNN or transformer-based architectures, with single-stage detectors like YOLO gaining prominence for real-time applications. Leading models in 2026 include RF-DETR, renowned for its high accuracy and adaptability across domains, and YOLO12 and YOLO26, which offer strong performance on edge devices. The choice of model depends on specific requirements, balancing accuracy and real-time processing needs, with considerations for licensing and deployment scenarios. The landscape is evolving towards zero-shot detection frameworks and integrating sophisticated image embedders, expanding the potential for high-precision detection on resource-constrained hardware.
Jul 07, 2026
3,097 words in the original blog post.
The recent update in Rider 2026.2 brings the powerful Natvis visualization tool to Linux and macOS, allowing developers to describe how their C++ types should appear in the debugger using simple XML, eliminating the need for complex data formatters previously required on these operating systems. This extension of functionality, previously exclusive to Windows, enhances the debugging experience by simplifying the representation of data structures like stacks, arrays, linked lists, and trees, making it easier to maintain and understand code. While Natvis offers broad compatibility with many existing C++ ecosystems, including game development engines like Godot and Unreal Engine, it currently relies on the standard LLDB expression evaluator on Linux and macOS, which may present challenges with more complex visualizations. However, developers can integrate Natvis with existing LLDB data formatters without conflict, allowing for a gradual adoption of this tool to improve project visibility and debugging efficiency.
Jul 06, 2026
1,514 words in the original blog post.
In a study conducted by JetBrains testing the "Caveman" skill for AI agents, it was found that the claimed token savings of 65% were significantly overstated, with actual savings closer to 8.5% when the skill was forcibly activated. The Caveman skill, designed to make AI agents communicate more concisely by reducing token usage in non-essential text while preserving code and tool instructions, showed no detectable degradation in task quality across 82 paired tasks. Despite promising cost reductions, the anticipated savings were often negated by single-trial variances due to the nature of the tasks. The study concluded that while the Caveman skill can be fun and harmless to use, its real-world applications in coding tasks offer only minor savings, highlighting the importance of comprehensive testing over relying on initial, smaller-scale evaluations.
Jul 06, 2026
1,031 words in the original blog post.
KotlinConf 2026 introduced the inaugural Golden Kodee Community Awards, celebrating individuals and communities that have significantly contributed to the Kotlin ecosystem through education, online presence, creativity, societal impact, and in-person engagement. The winners, including Matheus Leandro Ferreira, Jaewoong Eum, Nicole Terc, Eeva-Jonna Panula, and Yinlong Liu, exemplify the diverse strengths of the Kotlin community, with projects ranging from educational initiatives and content creation to fostering community collaboration and technological innovation. Their experiences highlight the importance of sharing knowledge and building connections within the community, emphasizing that contributions need not be grand to be impactful. The winners also expressed the personal and professional growth they have achieved through their involvement with Kotlin, illustrating the language's versatility and its supportive ecosystem. Their stories and advice encourage others to actively participate in and contribute to the Kotlin community, fostering a cycle of learning and growth.
Jul 03, 2026
2,649 words in the original blog post.
IntelliJ IDEA 2026.1.4 has been released, offering several key fixes to enhance user experience and functionality. Users can update to this version through the IDE, the Toolbox App, or via snaps for Ubuntu, and it is also available for download from the official website. Notable improvements include the correct updating of the active Git branch, a resolution for the issue in Docker Compose files that affected PHP interpreter creation, and a fix preventing successful Gradle syncs from being marked as failed when using Gradle 9.5.0 on WSL. Additionally, an error causing Dev Container connections to fail with an "Unknown Docker endpoint schema" message has been addressed. Detailed release notes are available for a comprehensive overview of these updates, and users are encouraged to report any issues through the issue tracker.
Jul 02, 2026
172 words in the original blog post.
Toolbox App 3.6 introduces significant improvements, including enhanced storage cleanup capabilities and better diagnostics for Windows installation issues. Users can now manage removable data more efficiently through the app's Settings, which provides a detailed breakdown of removable data like download caches and temporary leftovers, and can also set reminders for cleanup. The update also improves the Windows installer diagnostics by offering more precise information about issues such as file blockages and read-only errors, facilitating easier troubleshooting and log collection for support. Additionally, the CodeCanvas feature has been discontinued and removed from the app. Feedback from users is encouraged to further refine the app's functionality.
Jul 02, 2026
254 words in the original blog post.
Kotlin support has been integrated into BlueJ, a significant development for one of the most widely used educational environments for teaching introductory object-oriented programming (OOP). This collaboration between JetBrains and the BlueJ team at King’s College London aims to offer students an environment that reduces syntactic distractions and boilerplate code, making it easier to focus on core programming concepts. BlueJ's visual tools, such as class diagrams and object benches, help students conceptualize programs as systems of interacting objects, and Kotlin's concise syntax further enhances this learning experience by minimizing verbosity. The integration retains compatibility with the Java ecosystem, ensuring familiar ground for educators, while offering features like null safety and simplified variable declarations to aid understanding. An onboarding guide and teaching materials have been prepared to facilitate educators' transition to using Kotlin in their curriculum, with feedback from the BlueJ community playing a critical role in refining the release.
Jul 01, 2026
681 words in the original blog post.
Embedded software development faces challenges such as adhering to stringent safety and security standards, managing complex toolchains, and identifying defects early in the development cycle. JetBrains' CLion, in partnership with Parasoft C/C++test, offers an integrated solution to these challenges by enabling developers to conduct advanced static code analysis directly within their development environment. This integration supports compliance with industry standards like MISRA C/C++, AUTOSAR C++14, CERT C/C++, and CWE, and facilitates a seamless workflow by reducing context switching between development and verification tasks. Developers can utilize AI-assisted capabilities to gain insights into coding violations and receive suggestions for remediation, which is particularly beneficial when dealing with intricate standards. The system creates a continuous feedback loop by allowing Parasoft C/C++test analyses to be reused in CI/CD pipelines, ensuring consistency in verification throughout the software lifecycle. This integration is crucial for teams in industries such as automotive, medical devices, rail, aerospace, and industrial automation, where compliance and traceability are non-negotiable requirements.
Jul 01, 2026
534 words in the original blog post.
TeamCity has released two updates for its On-Premises servers: version 2026.1.2, which addresses over ten issues, including build command cancellations, Perforce changelist problems, AWS credential expirations, and AWS S3 signature mismatches, and version 2025.11.6, which focuses solely on resolving security issues. Users are encouraged to install these updates to enhance performance, integration compatibility, build stability, and security. The 2026.1.2 update is compatible with other 2026.1.x releases, allowing for easy upgrades without backup concerns, and users can access updates via automatic updates, direct downloads, or Docker images. For support, users are directed to the TeamCity Forum or Issue Tracker.
Jul 01, 2026
263 words in the original blog post.
JetBrains' engineering hiring process is a structured and comprehensive approach designed to evaluate not just technical skills but also the candidate's ability to think critically about problem-solving and understand the broader impact of their work. The process includes several stages: an initial CV review focusing on clarity and relevance, a recruiter call to assess alignment on skills and motivations, a team interview involving technical exercises and discussion of past projects, and a take-home task that reflects real-world challenges. The emphasis is on clear communication, decision-making, and understanding trade-offs. Successful candidates are those who demonstrate sound judgment, clean code, and the ability to explain their reasoning. The final stages involve task review, reference checks, and, if all aligns, an offer. JetBrains seeks engineers who are passionate about their craft and eager to contribute to meaningful projects, with the hiring process reflecting a commitment to building long-term, impactful teams.
Jul 01, 2026
1,527 words in the original blog post.