Qodana 2026.1: Rust EAP, Stable C/C++ Support, and New Code Inspections

Elizaveta Myšáková

Qodana 2026.1 release brings two important linter updates and a new set of inspections designed to help you catch more issues earlier in development. In this release, Qodana for C/C++ moves out of EAP, Qodana for Rust becomes available in EAP, and several new inspections add protection against subtle bugs in Kotlin, Python, and C#.

If you’re new to Qodana, you can learn more about Qodana in our previous posts.

Qodana for C/C++ is out of EAP

Qodana for C/C++ is now generally available, enhancing its readiness for production use in native code development. We introduced support for C/C++ projects back in 2025.1, and since then, the linter has been expanded and refined based on your feedback. It’s now ready for production use in native code development.

Thank you to everyone who tried qodana-cpp during its EAP! Here are some of the changes we’ve made based on your feedback:

• Qodana now properly detects build system failures, including for CMake and others, and helps you diagnose issues.
• For large projects, Qodana now features configurable timeouts via qd.cpp.startup.timeout.minutes:

# qodana.yaml
properties:
  qd.cpp.startup.timeout.minutes: "10"

• Cached build configurations in the .idea folder are simply ignored. We still advise cleaning cached files before running an analysis and closing any local IDE instances to avoid access conflicts with the .idea folder.
  

For more details, check out the C/C++ documentation and our previous post on the linter.

Qodana For C++ Info

The Qodana for Rust EAP is now open

With Qodana 2026.1, we’re launching the Early Access Program for Qodana for Rust. Adoption of Rust has grown significantly, with over 2.5 million developers using it in the last year. According to Stack Overflow, Rust has been the #1 most admired language for the past 10 years straight. And, there is strong demand from Rust teams working on infrastructure and performance-sensitive systems for safeguards. 

With this release, we aim to simplify the integration of static analysis into Rust workflows, supporting Rust’s growing use in infrastructure and performance-sensitive applications.
We’re bringing you:

• Over 150 inspections, including for dead code, lifetime issues, unsafe code, and more, as well as built-in cargo check and cargo clippy inspections.
• Conditional compilation, feature gating, and proc macro handling.
• Configurable Rust toolchain via rustup in the bootstrap block.
• Native support for multiple workspaces.

Your team can begin exploring automated inspections for Rust projects in CI and provide feedback as the linter develops. The current list of Rust inspections is available on Inspectopedia.

Qodana For Rust Info

New inspections in 2026.1

This release also adds new inspections for multiple ecosystems to help catch issues that can cause confusing behavior in production but that are easy to miss in the code review phase.

Kotlin: Suspicious ::javaClass callable reference

This inspection reports suspicious uses of the kotlin.jvm.javaClass extension as a callable reference.

Using ::javaClass syntax does not result in a Class<T> instance, as may be expected. Instead, it creates a property reference of type KProperty0<Class<T>>, which is almost never the intended behavior and can lead to hard-to-detect bugs.

fun test(a: String) {
    val classRef = a::javaClass // KProperty0<Class<String>>
    println(classRef) // Prints "property javaClass", not "class java.lang.String"
}

Python: Suspicious boolean condition

This inspection reports coroutines used in boolean contexts such as if, while, or ternary expressions, even in the absence of the await keyword.

A coroutine object itself is always truthy, so using it directly in a condition will evaluate as True even when that is not the intended logic. The actual result only becomes available after await. In practice, this inspection helps prevent async code from silently behaving incorrectly because a coroutine was checked instead of executed.

Wrong:

async def check() -> bool:
    return True

async def main():
    if check():  # Always True - coroutine object is truthy
        print("hi")

Expected:

async def main():
    if await check():  # Correctly awaits the coroutine
        print("hi")

C#: Short-lived HttpClient

This inspection reports short-lived uses of HttpClient. Frequently creating new HttpClient instances can lead to socket exhaustion and unnecessary resource pressure. In most cases, it is better to use IHttpClientFactory or a long-lived shared HttpClient instance.

This is the kind of issue that may not show up immediately during development, but can become a reliability problem under real traffic.

public class C
{
    static async Task<string> GetDataAsync(string url)
    {
        var client = new HttpClient() { Timeout = TimeSpan.FromMinutes(10) }; // Better to move in property
        var response = await client.GetAsync(url);
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadAsStringAsync();
    }
}

Coming soon…

• Code quality and security support for Laravel
• Project-specific code quality rules
• Additions to Insights like code provenance tracking 

What’s next for you?

If you’re already using the latest release, you’re ready to start using the improvements in Qodana 2026.1 right away. If not, update to 2026.1 to try the stable C/C++ linter, participate in the Rust EAP, and start benefiting from the new inspections for Kotlin, Python, and C#.

For setup details and feature-specific guidance, head over to the documentation. If you’d like to see what Qodana can do in your own environment, try it on your project and explore the latest updates on the Qodana blog.

Switch To Qodana