Qodana 2026.1 Help

Quick start

The current version of Qodana (2026.1) lets you analyze software that uses various programming languages and technologies. You can also extend the default Qodana configuration using available features.

As an example, this section explains how you can quickly start working with Qodana using:

Prerequisites

Set up your project in Qodana Cloud

Before running Qodana, you need to create a new organization and project in Qodana Cloud. This setup process will guide you through configuring your project for various CI/CD pipelines and local execution using Qodana CLI or JetBrains IDEs, and will generate a project token required by Qodana linters. Additionally, Qodana requires a connection to your repositories to track active contributors, as specified by our license agreement.

The project setup uses information from your JetBrains account, which includes licenses and companies.

GitHub Actions

If you plan to run the Qodana Scan GitHub action on a GitHub-hosted repository, you will need to install Qodana App during the project setup.

Authorize Qodana GitHub App

This GitHub application will make a single push of the following data to your repository:

If you do not have access to the repository that you intend to analyze, request the necessary access and wait for approval before proceeding. In other cases, you will receive instructions and configuration snippets that will help you start Qodana in your project.

Global configurations

During the project setup stage, you can choose a global configuration that will be used while analyzing your code.

Native mode

Native mode is incompatible with Docker containers of Qodana, which means that you can run Qodana either as a Docker container or in native mode.

If you wish to run Qodana in native mode using a command line, then install Qodana CLI on the machine where you will run it.

This is the list of technologies that you can use for configuring Qodana for native mode:

Language

Linter name(s)

Java, Kotlin, Groovy, JavaScript, TypeScript

qodana-jvm and qodana-jvm-community

PHP, JavaScript, TypeScript

qodana-php

JavaScript and TypeScript

qodana-js

C#, F#, VB.NET, JavaScript, TypeScript, C and C++

qodana-dotnet

Python, JavaScript, TypeScript

qodana-python and qodana-python-community

Go

qodana-go

.NET in native mode

Make sure that you have a proper version of the .NET SDK and all required dependencies installed on your machine.

Build the project before inspecting it using Qodana. You can do it by using the bootstrap key of the qodana.yaml file. The project building and artifact packaging stages should occur before Qodana or simultaneously with it. Because running Qodana may affect the project state and its files, it is advised to avoid reusing the same directory in your build pipelines any further.

You can also provide Qodana a pre-built project, or specify the build steps in your CI/CD pipeline. To remove warnings related to project building, in your repository create the empty qodana.yaml file.

It is also advised that you run the qodana-dotnet linter on the same machine where you build a project because this can guarantee that Qodana has access to private NuGet feeds.

Container mode

The container mode assumes that you have the Docker application deployed on your machine.

Pull the image from Docker Hub (only necessary to get the latest version):

docker pull <image>

Here, image denotes the Docker image name from this table:

Linter

Docker image

Java, Kotlin, Groovy, JavaScript, TypeScript

jetbrains/qodana-jvm:2026.1

jetbrains/qodana-jvm-community:2026.1

jetbrains/qodana-jvm-android:2026.1

jetbrains/qodana-android:2026.1

PHP, JavaScript, TypeScript

jetbrains/qodana-php:2026.1

JavaScript and TypeScript

jetbrains/qodana-js:2026.1

C#, C/C++, VB.NET, JavaScript, TypeScript, F#

jetbrains/qodana-dotnet:2026.1<-privileged>

jetbrains/qodana-cdnet:2026.1-eap<-privileged>

Python, JavaScript and TypeScript

jetbrains/qodana-python:2026.1

jetbrains/qodana-python-community:2026.1

Golang, JavaScript and TypeScript

jetbrains/qodana-go:2026.1

Ruby, JavaScript and TypeScript

jetbrains/qodana-ruby:2026.1-eap<-ruby3.X><-privileged>

C and C++

jetbrains/qodana-clang:2026.1-eap<-clangXX>

jetbrains/qodana-cpp:2026.1<-clangXX><-privileged>

Rust

jetbrains/qodana-rust:2026.1-eap

The table contains optional tags to let you pull pre-configured Qodana images:

  • The -clangXX tag configures the Clang-Tidy version from 15 to 18.

  • The -ruby3.X tag configures the Ruby version from 3.1 to 3.4. If not specified, version 3.4 will be used.

    The -privileged tag lets you run Qodana in the privileged mode to execute commands that require root access. In this case, Qodana comes with a default qodana user that possesses root privileges and does not require a password. Where applicable, this tag requires the -clangXX and -ruby3.X tags to be configured.

Qodana CLI

Qodana CLI is the easiest way for running Qodana when using the command-line interface suitable for both native and container modes.

To run Qodana CLI in the default mode, you must have Docker or Podman installed and running locally. If you are using Linux, you should be able to run Docker under your current non-root user.

Install Qodana CLI on your machine using available options:

Install with Homebrew (recommended):

brew install jetbrains/utils/qodana

Alternatively, you can install Qodana CLI using our installer:

curl -fsSL https://jb.gg/qodana-cli/install | bash

You can install a nightly or any other version the following way:

curl -fsSL https://jb.gg/qodana-cli/install | bash -s -- nightly

On Linux, you can also install Qodana using Go:

go install github.com/JetBrains/qodana-cli@latest

Install with Windows Package Manager (recommended):

winget install -e --id JetBrains.QodanaCLI

Install with Chocolatey:

choco install qodana

Install with Scoop:

scoop bucket add jetbrains https://github.com/JetBrains/scoop-utils scoop install qodana

Different Docker contexts or Podman

Qodana uses Docker CLI to communicate with the container engine and employs a Docker context enabled at the time of execution. For example, to use Podman as your container engine, you will need to either:

  • In Podman Desktop, enable Docker compatability mode and disable Docker so that Podman listens on /var/run/docker.sock, or

  • Use the Podman socket to create a Docker context. If you are using Podman Desktop, you can find the socket path under Settings > Resources

You can confirm which engine is activated by running the docker version command.

Run Qodana in JetBrains IDEs

Qodana is available in several IDEs by JetBrains, such as IntelliJ IDEA, PhpStorm, WebStorm, GoLand, PyCharm, Rider, and CLion.

Here is a short animation showing how you can run Qodana in your IDE.

Running Qodana in an IDE

Here is the description of all steps shown in this animation:

  1. In your IDE, navigate to the Problems tool window.

  2. In the Problems tool window, click the Qodana tab.

  3. On the Qodana tab, click the Try locally button to start Qodana.

  4. On the Qodana tab, you can view analysis results. It also contains two links in the upper part of the tab.

    Links on the Qodana tab

    Open the analysis report in your browser.

    Qodana report

    Open the configuration wizard to use Qodana in CI/CD pipelines.

    Qodana in CI/CD pipelines

    To learn more about Qodana and CI/CD pipelines, see the Overview of CI integration section.

You can also learn how to install Qodana using the recommendations from the Visual Studio and Visual Studio Code sections.

Run Qodana using CLI

This section assumes that you have completed the steps from the Prerequisites chapter.

  1. In the project root directory, declare the QODANA_TOKEN variable containing the project token described in the prerequisites:

    QODANA_TOKEN=<cloud-project-token>
    set QODANA_TOKEN=<cloud-project-token>

  2. To run Qodana in native mode, use this command:

    qodana scan \    --linter <linter-name> \    --within-docker false
    qodana scan ^    --linter <linter-name> ^    --within-docker false

    In this command, the --linter option instructs Qodana about a linter that should be invoked. The --within-docker false option instructs Qodana to enable native mode. These options tell Qodana to download and employ the required JetBrains IDE binary file while running a Qodana linter.

    To run Qodana in container mode, use the following command:

    qodana scan
    qodana scan

This section assumes that you have used the recommendations from the Prerequisites chapter.

  1. Run this command to analyze your codebase:

    docker run \ -v <source-directory>/:/data/project/ \ -e QODANA_TOKEN="<cloud-project-token>" \ jetbrains/qodana-<image>

    Here, <source-directory> points to the root of your project, and the QODANA_TOKEN variable contains the project token described in the prerequisites.

  2. Navigate to your Qodana Cloud account to see analysis results.

Run Qodana using CI/CD

For Azure Pipelines, CircleCI, GitHub Actions, GitLab CI/CD, and TeamCity, Qodana provides native solutions. To run Qodana using Bitbucket Cloud, and Jenkins, you can use Docker images.

Here is a short animation showing how you can configure and run Qodana using GitHub Actions.

Running Qodana in GitHub

Assuming that you already generated a project token as described in the Prerequisites chapter, follow these steps to configure Qodana for running in native mode:

  1. On the Settings tab of the GitHub UI, create the QODANA_TOKEN encrypted secret and save the project token as its value. If you are using a Qodana Cloud instance other than https://qodana.cloud/, override it by declaring the QODANA_ENDPOINT environment variable.

  2. On the Actions tab of the GitHub UI, set up a new workflow and create the .github/workflows/code_quality.yml file.

  3. To analyze the main and master branches, as well as release branches and the pull requests coming to your repository, save this workflow configuration to the .github/workflows/code_quality.yml file:

    name: Qodana on: workflow_dispatch: pull_request: push: branches: # Specify your branches here - main # The 'main' branch - master # The 'master' branch - 'releases/*' # The release branches jobs: qodana: runs-on: ubuntu-latest permissions: contents: write pull-requests: write checks: write steps: - uses: actions/checkout@v3 with: ref: ${{ github.event.pull_request.head.sha }} # to check out the actual pull request commit, not the merge commit fetch-depth: 0 # a full history is required for pull request analysis - name: 'Qodana Scan' uses: JetBrains/qodana-action@v2026.1 with: args:| --linter <linter-name> --within-docker false env: QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}

    In the args block, the --linter option instructs Qodana about a linter that should be invoked. The --within-docker false option instructs Qodana to enable native mode. These options tell Qodana to download and employ the required JetBrains IDE binary file while running a Qodana linter.

    name: Qodana on: workflow_dispatch: pull_request: push: branches: # Specify your branches here - main # The 'main' branch - master # The 'master' branch - 'releases/*' # The release branches jobs: qodana: runs-on: ubuntu-latest permissions: contents: write pull-requests: write checks: write steps: - uses: actions/checkout@v3 with: ref: ${{ github.event.pull_request.head.sha }} # to check out the actual pull request commit, not the merge commit fetch-depth: 0 # a full history is required for pull request analysis - name: 'Qodana Scan' uses: JetBrains/qodana-action@v2026.1 env: QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}

Run Qodana as a Gradle plugin

The Gradle Qodana plugin provides the Gradle interface for running code inspections provided by Qodana. To start, apply the Gradle plugin org.jetbrains.qodana in the Gradle configuration file.

Add the following to the build.gradle configuration file.

plugins { id "org.jetbrains.qodana" version "<plugin-version>" }

Add the following to the build.gradle.kts configuration file:

plugins { id("org.jetbrains.qodana") version "<plugin-version>" }

qodana { } extension configuration

Properties available for configuration in the qodana { } top-level configuration closure:

Name

Description

Type

Default Value

projectPath

Path to the project folder to analyze.

String

project.projectDir

resultsPath

Path to the directory to store task results.

String

"${projectPath}/build/qodana/results"

cachePath

Path to the directory to store the generated report.

String

"${projectPath}/build/qodana/cache/"

Gradle Qodana Tasks

qodanaScan

Start Qodana in the project directory.

The task relies on the qodana { } extension configuration. However, it is also controlled by provided arguments.

Example

Add this to your Gradle configuration file:

  • Groovy – build.gradle

    plugins { // applies Gradle Qodana plugin to use it in project id "org.jetbrains.qodana" version "..." } qodana { // by default result path is $projectPath/build/results resultsPath = "some/output/path" } qodanaScan { arguments = ["--fail-threshold", "0"] }

  • Kotlin – build.gradle.kts

    plugins { // applies Gradle Qodana plugin to use it in a project id("org.jetbrains.qodana") version "..." } qodana { // by default, the result path is $projectPath/build/results resultsPath.set("some/output/path") } qodanaScan { resultsPath.set("some/output/path") arguments.set(listOf("--fail-threshold", "0")) }

Now you can run analyses using the qodanaScan Gradle task:

gradle qodanaScan // or ./gradlew qodanaScan

A complete guide for options and configuration of arguments parameters can be found on Qodana CLI docs page.

Next steps

21 April 2026
LicensesIntroduction