---
title: "Jetbrains"
description: "Software development company that builds smart programming tools, especially integrated development environments (IDEs), to help developers write and fix code efficiently"
---

# Jetbrains
> Software development company that builds smart programming tools, especially integrated development environments (IDEs), to help developers write and fix code efficiently

## Articles

### [Small Talk With Prasun Kumar, CEO and Founder of Oppex AI](https://yomu.fyi/post/small-talk-with-prasun-kumar-ceo-and-founder-of-oppex-ai.md)
- Company: [Jetbrains](https://yomu.fyi/company/jetbrains.md)
- Author: Mitsal Athaya
- Published: Sep 23, 2026
- Type: Explainer

Oppex AI builds AI agents that help developers resolve production incidents by gathering context before the engineer is paged. The agents collect logs, cloud metrics, database health, affected customers, recent code changes, and past incident history, then present a recommendation. Because developer logs are not plain English, the team constructs a knowledge graph of how the entire system connects. They harden the agent by pitting it against a chaos monkey that breaks test systems without revealing the method, forcing the agent to learn. The 15-person team has launched the product with early enterprise customers and aims to bring mean time to resolve under 10 minutes, eventually moving toward autonomous system healing.


### [100 Exercises to Learn Rust, Updated](https://yomu.fyi/post/100-exercises-to-learn-rust-updated.md)
- Company: [Jetbrains](https://yomu.fyi/company/jetbrains.md)
- Author: Daria Kolodzey
- Published: Sep 23, 2026
- Type: Tutorial

The post announces a major update to the free JetBrains Academy course ‘100 Exercises to Learn Rust,’ which runs inside RustRover. The course teaches Rust through hands-on exercises building a ticket management system across eight chapters from ownership to futures, assuming fluency in another language. The update adds a rebuilt introduction, an FAQ, a final challenge turning the system into an async REST API by editing Cargo.toml and verifying with a requests.http file, visible test assertions, and a dev/release profile experiment. A ‘fast track’ lets experienced users skip to the final challenge to quickly see which areas need revisiting. The post advises using AI for explanations, not code generation, and turning off AI code completion during exercises to maximize learning from getting stuck and working out solutions.


### [Code Quality Q&A With the JetBrains Qodana Team](https://yomu.fyi/post/code-quality-q-a-with-the-jetbrains-qodana-team.md)
- Company: [Jetbrains](https://yomu.fyi/company/jetbrains.md)
- Author: Kerry Beetge
- Published: Sep 22, 2026
- Type: Explainer

The Qodana team answers frequently searched questions about code quality, distinguishing technical debt from poor code quality and offering practices to reduce cognitive complexity in nested loops. They explain that code coverage measures how much production code is executed by unit tests, while mutation testing evaluates test quality by checking whether tests detect deliberate code changes. Unit tests provide the fastest feedback on code changes by catching regressions close to their introduction and making refactoring safer. To track improvement, teams should monitor static analysis trends such as new issues and technical debt, and also look for fewer Sev 1 issues in production and faster mean time to repair. False positives in automated scanning can be reduced by giving the tool more repository context, such as excluding inspections in qodana.yaml or silencing them with inline comments.


### [JetBrains Air: Building a System of Products for Agentic Software Development](https://yomu.fyi/post/jetbrains-air-building-a-system-of-products-for-agentic-software-devel.md)
- Company: [Jetbrains](https://yomu.fyi/company/jetbrains.md)
- Author: Kirill Skrygan
- Published: Sep 22, 2026
- Type: Announcement

JetBrains Air is a system of products for agentic software development, built on the premise that no single model, agent, or service fits every developer, team, or task. It connects products for individual work, team coordination, organizational control, context, and process automation, while remaining open to tools and agents developers choose, including those JetBrains does not build. This openness lets developers select the agent, model, or service suited to a task without forcing the organization to give up context, visibility, or control. The Post notes that every new model, agent, or service an organization adds reduces visibility into its own development work. Because intelligence does not belong to one model, the benefit can extend across supported agents and services.


### [The AIDEs Framework: How We Built a “Theory of Everything” for AI Development Tools](https://yomu.fyi/post/the-aides-framework-how-we-built-a-theory-of-everything-for-ai-develop.md)
- Company: [Jetbrains](https://yomu.fyi/company/jetbrains.md)
- Author: Stanislav Tikhomirov
- Published: Sep 18, 2026
- Type: Explainer

JetBrains presents the AIDEs Framework as a model for understanding how AI development tools evolve, rather than trying to track every market change. The post describes a progression from single-line completion through multiline completion, IDE chat, AI code editors, agentic development environments, and cloud-based agents. It defines an Artificial Intelligent System as a system that demonstrates intelligence in helping users achieve goals, and an Artificial Intelligent Development Environment (AIDE) as an AIS for creating software; intelligence may come from deterministic heuristics as well as LLMs. The framework treats principals and agents as potentially human or AI actors and views software creation as a broader delegation process than coding alone. It proposes examining assumptions, building a model, and validating it against ongoing change, while suggesting a possible future of vertically integrated Agentic Software Production Platforms that use AI as an “intelligence” resource.


### [Making Local AI Smarter and Faster](https://yomu.fyi/post/making-local-ai-smarter-and-faster.md)
- Company: [Jetbrains](https://yomu.fyi/company/jetbrains.md)
- Author: Vladimir Sotnikov
- Published: Sep 18, 2026
- Type: Announcement

Junie Local’s update introduces Qwen3.8-3.6-27B-blend, a merged model that balances speed and capability for local coding agents. The blend, created by merging Qwen3.6 and Qwen3.8 weights in equal proportions, completed 37 tasks in a 100-task internal benchmark, compared to 34 for Qwen3.6 and 39 for Qwen3.8, while generating 71% fewer output tokens than Qwen3.8. The runtime uses multi-token prediction (MTP), with a two-token proposal on M5 MacBook Pro making decoding 60% faster. A four-bit MTP head was kept over an eight-bit one due to similar acceptance rates and memory savings. The update also brings experimental NVIDIA RTX support on Windows for machines with at least 24 GB of VRAM.


### [Your diff has a demo now with Junie /demo](https://yomu.fyi/post/your-diff-has-a-demo-now-with-junie-demo.md)
- Company: [Jetbrains](https://yomu.fyi/company/jetbrains.md)
- Author: Aliaksei Kartynnik
- Published: Sep 18, 2026
- Type: Tutorial

Junie /demo adds a mode to Junie CLI that builds and launches an application, drives its UI, and records a requested check. It produces an HTML report, screenshots, and video, while leaving reviewers able to inspect steps, outcomes, and evidence. In the example, a prompt selects two issues, marks them Done, checks counter changes, reloads the page, and verifies persistence. Initial setup analyzes the repository and generates configuration after a confirmed build and launch plan; Docker-based environments can use custom templates for complex repositories. The mode also supports GitHub Actions workflows for pull-request demonstrations and release smoke tests, but an explicit PASS verdict is required for a scenario to pass.


### [Ktor 3.6.0 Is Now Available!](https://yomu.fyi/post/ktor-3-6-0-is-now-available.md)
- Company: [Jetbrains](https://yomu.fyi/company/jetbrains.md)
- Author: Simon Vergauwen
- Published: Sep 18, 2026
- Type: Announcement

Ktor 3.6.0 introduces experimental typed authentication with full type safety, including role-based access and anonymous users, plus a dedicated OpenID Connect plugin that supports sessions and auto-refreshing tokens, and experimental HTTP/3 support for the Netty engine via QUIC. Request-parameter conversion now supports Kotlin’s Uuid, Byte, and unsigned numeric types, while receive() accepts nullable types, deprecating receiveNullable(), and more flexible routing syntax. The ContentNegotiation plugin gains a ContentTypeMergeStrategy.SkipIfPresent to preserve explicit Accept headers. Kotlin Multiplatform projects benefit from the ktor-client-engine-defaults artifact and file-based HttpCache storage using kotlinx-io Path, simplifying cross-platform configuration. Additional improvements include respondHtmlPartial for partial HTML output, asynchronous DNS resolution for the CIO engine, and WebRTC support for JVM.


### [Building a RAG Pipeline for Semantic Code Search: A Developer Diary and Field Notes](https://yomu.fyi/post/building-a-rag-pipeline-for-semantic-code-search-a-developer-diary-and.md)
- Company: [Jetbrains](https://yomu.fyi/company/jetbrains.md)
- Author: Adam Malek
- Published: Sep 17, 2026
- Type: Explainer

JetBrains Context is presented as a production RAG pipeline for semantic code search, designed to give coding agents precise, citable evidence from repositories instead of relying on keyword tools such as grep. This first installment covers parsing, structure-aware chunking, and vectorization, with the goal of retrieving meaningful functions, symbols, or snippets rather than whole files or insignificant lines. Language parsers produce syntax nodes, and the algorithm retains the largest units that fit, splits oversized leaf nodes when necessary, groups small adjacent units, and keeps documentation, annotations, modifiers, and closing syntax with their constructs. JetBrains Context supports this approach for Kotlin, Java, Python, JavaScript, TypeScript, C#, PHP, Go, and Rust; other languages use line-based splitting. Vectors are generated with an open-weight model on company-operated GPUs, while indexed records store coordinates rather than source code, and the post reports that this setup outperformed hosted embedding APIs on internal code-retrieval benchmarks.


### [Logpoints Walkthrough](https://yomu.fyi/post/logpoints-walkthrough.md)
- Company: [Jetbrains](https://yomu.fyi/company/jetbrains.md)
- Author: Igor Kulakov
- Published: Sep 16, 2026
- Type: Tutorial

Logpoints in IntelliJ IDEA provide a way to inspect a running Java process without suspending it, making them useful when println logging or regular breakpoints would be disruptive. The walkthrough uses a Dockerized gRPC client and server whose incorrect tenant discount is traced by attaching to the server and adding expressions at runtime, without rebuilding or redeploying. Progressive logging shows the tenant value as JetBrains while the expected value is jetbrains, and the correct-discount block is never entered; the supplied fix uses equalsIgnoreCase and returns 2,000 basis points. The article also demonstrates testing changes through logpoint side effects, extending gRPC deadlines selectively, logging in dependencies, and using the ij-debugger AI agent skill. IntelliJ IDEA 2026.2 adds faster placement and instrumentation that removes debugger-introduced overhead, although heavy expressions still execute in the VM.


### [Rider and ReSharper 2026.2.2 Are Out!](https://yomu.fyi/post/rider-and-resharper-2026-2-2-are-out.md)
- Company: [Jetbrains](https://yomu.fyi/company/jetbrains.md)
- Author: Alexander Kurakin
- Published: Sep 16, 2026
- Type: Announcement

Version 2026.2.2 of ReSharper, Rider, and .NET tools is available through the products, Toolbox App, or website. Rider adds an AI Agent Setup widget to the bottom-right status bar, where users can review supported MCP tools, skills, and hooks, see which are enabled, and open the relevant settings. Its hooks now give agents narrower inspection results for newly added code, while the Reformat file hook reports IDE formatting changes as a diff; dotCover also adds TUnit coverage, requiring JetBrains.dotCover.Framework and Microsoft.Testing.Platform 2.3.0 or later. The release fixes a macOS backend-resume freeze, removes dependence on Unity editor executable names for attachment, and enables MCP file operations across attached solution folders; ReSharper also receives TUnit coverage support.


### [Behind the Scenes: How the OpenTelemetry Plugin Maps Your Microservices in Real-Time](https://yomu.fyi/post/behind-the-scenes-how-the-opentelemetry-plugin-maps-your-microservices.md)
- Company: [Jetbrains](https://yomu.fyi/company/jetbrains.md)
- Author: Nikita Dukin
- Published: Sep 16, 2026
- Type: Explainer

Outdated architecture diagrams and static code analysis can miss how services are connected at runtime, so the OpenTelemetry plugin builds a Service Map from live telemetry. With a lightweight local OpenTelemetry backend, the plugin supplies standard OTel environment variables, receives application spans, and continuously updates an internal architecture model that the IDE renders on demand. Its stream-processing algorithm classifies spans through semantic attributes, identifies services, matches HTTP CLIENT and SERVER spans across propagated trace context, and infers database or messaging dependencies while retaining unmatched spans in memory. Because spans can arrive out of order and traces have no definitive finish signal, the map is incrementally reconstructed rather than built from complete traces; the result is a language- and vendor-agnostic view for OpenTelemetry-instrumented applications across several JetBrains IDEs.


### [Java 27 in IntelliJ IDEA](https://yomu.fyi/post/java-27-in-intellij-idea.md)
- Company: [Jetbrains](https://yomu.fyi/company/jetbrains.md)
- Author: Marit van Dijk
- Published: Sep 15, 2026
- Type: Explainer

Java 27, released on September 15, 2026, follows Java’s six-month release cadence and includes nine JEPs: four final features, four previews, and one incubator feature. IntelliJ IDEA supports Java 27 from day one, with setup through Project Structure, automatic JDK configuration from .sdkmanrc or .tool-versions, and language-level controls for stable and preview features. Stable changes include G1 as the default garbage collector in all environments, hybrid post-quantum key exchange for TLS 1.3, compact object headers by default, and JFR in-process data redaction. Preview and incubator work covers lazy constants, primitive types in patterns, instanceof, and switch, PEM cryptographic encodings, and the Vector API, while faster debugger stepping is available through a JDK 27 fix also backported to JBR 25.


### [Toolbox App 3.8: Improves IDE Update Handling on macOS and Fixes Keyboard Navigation](https://yomu.fyi/post/toolbox-app-3-8-improves-ide-update-handling-on-macos-and-fixes-keyboa.md)
- Company: [Jetbrains](https://yomu.fyi/company/jetbrains.md)
- Author: Ivan Kuzmin
- Published: Sep 14, 2026
- Type: Announcement

Toolbox App 3.8 addresses IDE update handling on macOS and restores keyboard navigation in project and tool lists. On macOS, manual IDE updates remain available when the system incorrectly reports an installation directory as non-writable, with instructions shown if macOS blocks the update. On Windows, Ctrl+1 and Ctrl+2 switch between the Tools and Projects tabs, while the Up Arrow, Down Arrow, Page Up, Page Down, Home, and End keys navigate lists, including filtered results. Cleanup of leftover IDE directories now displays progress for each tool and the full operation, and disables delete controls until cleanup and rescanning finish, preventing duplicate cleanup starts.


### [Join Us at the Zephyr Project Meetup in Amsterdam](https://yomu.fyi/post/join-us-at-the-zephyr-project-meetup-in-amsterdam.md)
- Company: [Jetbrains](https://yomu.fyi/company/jetbrains.md)
- Author: Maria Goldade
- Published: Sep 10, 2026
- Type: Announcement

The Zephyr community will meet in person at JetBrains Amsterdam on September 15, 2026, for a free evening focused on the open-source real-time operating system for resource-constrained and connected devices. The meetup brings together contributors, embedded developers, and others to exchange practical experience and discuss the ecosystem through talks on developer tooling, firmware testing, AI-assisted development, migration, and education. One session will show how AFL and the Renode simulator can fuzz Zephyr firmware without physical hardware, while another presents AI-assisted setup from environment configuration through compiling, flashing, and running an application on a board. The agenda also covers JetBrains’ collaboration with Zephyr and a migration from bare-metal and FreeRTOS code to a shared codebase targeting Renesas, STM32, and Nordic hardware. Registration is required, seats are limited, and presentations will be in English and Dutch.


### [Why Rider and ReSharper Were Slow to Start, and How Microsoft Helped Fix the Problem](https://yomu.fyi/post/why-rider-and-resharper-were-slow-to-start-and-how-microsoft-helped-fi.md)
- Company: [Jetbrains](https://yomu.fyi/company/jetbrains.md)
- Author: Alexander Ulitin
- Published: Sep 9, 2026
- Type: Explainer

After ReSharper’s out-of-process (OOP) architecture launched, users reported slower Windows startup, and profiling traced the delay to Microsoft Defender scanning the separate process. Defender spends only a couple of seconds on processes in write-protected paths but can add tens of seconds when ReSharper loads DLLs from a user installation directory. The investigation used Microsoft Defender ETW logs and direct CPU-time measurements, with cold-start tests repeated 10 times inside an 8-vCPU, 8-GB Hyper-V VM; JetBrains IDEs took roughly 10–40 seconds to scan, while Microsoft IDEs and other editors stayed under one second. Collaboration with Microsoft led to Defender optimizations in version 1.449.454.0, improving scanning for ReSharper OOP and Rider in write-protected directories. JetBrains also released the Defender Performance Tool for live monitoring, offline snapshots, and CSV export.


### [Get Gemini 3.8 Flash With 75% Off](https://yomu.fyi/post/get-gemini-3-8-flash-with-75-off.md)
- Company: [Jetbrains](https://yomu.fyi/company/jetbrains.md)
- Author: Dmitry Savelev
- Published: Sep 9, 2026
- Type: Announcement

Google’s Gemini 3.8 Flash is now available in Junie’s IDE plugin and Junie CLI, accompanied by a limited-time 75% introductory discount. The model targets long, multi-step engineering tasks: it spends more tokens exploring directories, retrying failed code, writing bug-reproduction scripts, running tests through tool calls, and checking changes before completion. Google’s DeepSWE v1.1 testing is described as showing 3.8 Flash outperforming most larger frontier models at significantly lower cost, although the source does not provide specific scores. Gemini 3.7 Flash remains available for minor fixes and small refactorings, where its lower per-token cost may be preferable, while 3.8 Flash can be selected from the model picker without setup or a waitlist.


### [Join our live webinars: Migrating from Atlassian to YouTrack](https://yomu.fyi/post/join-our-live-webinars-migrating-from-atlassian-to-youtrack.md)
- Company: [Jetbrains](https://yomu.fyi/company/jetbrains.md)
- Author: Elena Pishkova
- Published: Sep 9, 2026
- Type: Announcement

YouTrack announces live webinars for teams considering migration from Atlassian after Atlassian’s stated discontinuation of Data Center sales and support. The worldwide English-language session is scheduled for September 30, 2026, at 2:00 pm CET on YouTube, alongside a Japanese Zoom session and a Russian-language regional session hosted by Noventiq on October 28. The agenda covers migrating projects, users, and data from Jira, Confluence, and Jira Service Management, with a live demo, customer stories, pricing, licensing, deployment options, user packs, and partner support. It is aimed at administrators, project managers, and team leads, and presents YouTrack as a place to combine project management, documentation, and customer support. The Japan session additionally covers workflow automation and connecting AI agents through MCP, while registration for the Asia and Caucasus session is not yet open.


### [Rust AI in Practice: Building LLM Applications With Rig](https://yomu.fyi/post/rust-ai-in-practice-building-llm-applications-with-rig.md)
- Company: [Jetbrains](https://yomu.fyi/company/jetbrains.md)
- Author: Irina Mihajlovic
- Published: Sep 9, 2026
- Type: Explainer

Rig is an open-source Rust library that provides a common interface for LLM providers including OpenAI, Anthropic, and Gemini, avoiding application rewrites when switching services. It structures applications around a provider client, completion model, agent, preamble, and registered tools, with async APIs handling provider network requests. In the Rat Code demo, built with Ratatui, separate tools read and write files and run shell commands, while Rig’s streaming API updates the terminal as responses arrive. The library also supports RAG through vector store abstractions, local inference via Ollama, llama.cpp, or Candle, and cassette-based integration tests that replay recorded HTTP interactions in CI; live model quality requires separate scheduled testing.


### [The Evolution of WSL Support in JetBrains IDEs](https://yomu.fyi/post/the-evolution-of-wsl-support-in-jetbrains-ides.md)
- Company: [Jetbrains](https://yomu.fyi/company/jetbrains.md)
- Author: Kristina Pchelintseva
- Published: Sep 9, 2026
- Type: Explainer

JetBrains IDEs have supported WSL through several architectures, but the 2026.2 release makes Native mode the recommended entry point for projects stored there. In Native mode, the Windows IDE delegates filesystem and process operations to the Rust-based IJent agent inside WSL, with EelApi abstracting local and remote environments for IDE and plugin code. Earlier approaches included 9P filesystem access, WSLg, and Remote Development, with problems involving symlink handling, latency, GUI limitations, installation overhead, and client–backend communication costs. Performance tests on a cold first open of spring-framework measured Native mode at 11.5 seconds to become ready versus 18.5 seconds for 9P, while project-tree scanning took 3.7 versus 8.1 seconds. Remote Development remains available, but direct project opening is now preferred in IntelliJ IDEA, WebStorm, and PhpStorm.


[Newer posts](https://yomu.fyi/company/jetbrains/page/2.md) · [Older posts](https://yomu.fyi/company/jetbrains/page/4.md)