# Quarkus

> **TL;DR**
> Required plugin: Quarkus (bundled)

[Quarkus](https://quarkus.io/) is a Kubernetes-native Java framework mainly aimed at building microservices.

IntelliJ IDEA provides the following:

* A dedicated project creation wizard based on [code.quarkus.io](https://code.quarkus.io/).

* [A dedicated run configuration for Quarkus applications](quarkus-run-configuration.html).

* Coding assistance specific to Quarkus.

* Integration with the [Beans](beans-tool-window.html) and [Endpoints](endpoints-tool-window.html) tool windows.

Procedure: Create a new Quarkus project

1. Launch IntelliJ IDEA.

If the Welcome screen opens, click New Project.

Otherwise, go to `File | New | Project…` in the main menu.

2. Select Quarkus from the left pane.

* Click ![the Configure icon](https://resources.jetbrains.com.cn/help/img/idea/2026.2/app.expui.general.settings.svg) to enter the URL of the service that you want to use, or leave the default one.

* Specify a name and location for your project and configure project metadata: select a language, a build tool, and specify an artifact ID.

* From the JDK list, select the [JDK](sdk.html#jdk) that you want to use in your project. * If the JDK is installed on your computer, but not defined in the IDE, select ![](https://resources.jetbrains.com.cn/help/img/idea/2026.2/app.expui.nodes.jdk.png) Add JDK from Disk… and specify the path to the JDK home directory. * If you don't have the necessary JDK on your computer, select ![](https://resources.jetbrains.com.cn/help/img/idea/2026.2/app-client.expui.general.download.svg) Download JDK .

* Select the Add sample code option to create a REST endpoint named `ExampleResource` together with the project.

![New Quarkus project wizard](https://resources.jetbrains.com.cn/help/img/idea/2026.2/quarkus-new-project.png)

Click Next.

3. On the next step of the wizard, from the Extensions list, select the necessary options  and click Create.

If you have selected the Add sample code option in the New Project wizard, the generated project will contain a REST endpoint named `ExampleResource` with the following code:

```JAVA
package com.example;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

@Path("/hello")
public class ExampleResource {

    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String hello() {
        return "Hello from RESTEasy Reactive";
    }
}
```

You can open the [Endpoints](endpoints-tool-window.html) tool window (`View | Tool Windows | Endpoints`) and see this endpoint:

![ExampleResource endpoint in the Endpoints tool window](https://resources.jetbrains.com.cn/help/img/idea/2026.2/quarkus-hello-endpoint.png)

Procedure: Run the Quarkus application

IntelliJ IDEA creates a Quarkus run configuration that executes the necessary Maven goal or Gradle task.

* Select the Quarkus run configuration in the main toolbar and click ![The Run icon](https://resources.jetbrains.com.cn/help/img/idea/2026.2/app.expui.run.run.svg) or press `Shift+F10` (Windows), `⌃ R` (macOS), `⇧ F10` (IntelliJ IDEA Classic (macOS)), `⌥ ⇧ R` (macOS System Shortcuts), `Shift+F10` (XWin), `Shift+F10` (GNOME), `Shift+F10` (KDE), `Shift+F10` (Emacs), `Shift+F10` (Sublime Text), `Shift+F10` (Sublime Text (macOS)), `F6` (NetBeans), `Ctrl+F5` (Visual Studio), `⌃ F5` (Visual Studio (macOS)), `Alt+Shift+X` (Eclipse), `⌘ ⇧ F11` (Eclipse (macOS)).

Alternatively, you can press `Alt+Shift+F10` (Windows), `⌃ ⌥ R` (macOS), `⌥ ⇧ F10` (IntelliJ IDEA Classic (macOS)), `⌃ ⌥ R` (macOS System Shortcuts), `Alt+Shift+F10` (XWin), `Alt+Shift+F10` (GNOME), `Alt+Shift+F10` (KDE), `Alt+Shift+F10` (Emacs), `Alt+Shift+F10` (Sublime Text), `⌃ ⌥ R` (Sublime Text (macOS)), `Alt+Shift+F10` (NetBeans), `Ctrl+Alt+Shift+R` (Visual Studio), `⌘ ⌥ ⇧ R` (Visual Studio (macOS)), `Alt+Shift+F10` (Eclipse), `⌃ ⌥ R` (Eclipse (macOS)) and select the necessary run configuration.

If successful, you should see the output log in the Run tool window.

![Quarkus application running in the Run tool window](https://resources.jetbrains.com.cn/help/img/idea/2026.2/quarkus-run-tool-window.png)

By default, the application starts on [http://localhost:8080](http://localhost:8080). Open this address in a web browser to see the Quarkus landing page:

![Quarkus application start page](https://resources.jetbrains.com.cn/help/img/idea/2026.2/quarkus-start-page.png)

If you open the [http://localhost:8080/hello](http://localhost:8080/hello) endpoint, you will see the string `Hello from RESTEasy Reactive`.

The default configuration runs your Quarkus application in development mode, which enables background compilation. For example, you can change the string returned by the `hello()` method in the `ExampleResource` class to `Hello from a modified Quarkus endpoint` and you will see this new string after you refresh [http://localhost:8080/hello](http://localhost:8080/hello) without restarting your application.

Procedure: Open Quarkus Dev UI

You can open the [Quarkus Dev UI](https://quarkus.io/guides/dev-ui) right in the IDE.

1. [Run a Quarkus application](#run-app).

2. In the Run tool window, click ![Quarkus icon](https://resources.jetbrains.com.cn/help/img/idea/2026.2/quarkus.icons.quarkus.svg) (Open Quarkus Dev UI).

This will open the Quarkus Dev UI in a new editor tab.

![Quarkus Dev UI](https://resources.jetbrains.com.cn/help/img/idea/2026.2/quarkus_dev_ui.png)

Procedure: Add extensions to existing Quarkus projects

[Quarkus extensions](https://code.quarkus.io/) are pre-configured sets of your project dependencies.

When you create a new Quarkus project with IntelliJ IDEA, you can add extensions in the [dedicated new project wizard](#new_microservice_project). You can also add them to existing projects using Add Extensions  inlay hints in your build files.

1. Open your `pom.xml` or `build.gradle(.kts)` file.

2. In the `dependencies` block, click  ![Quarkus Edit Extensions](https://resources.jetbrains.com.cn/help/img/idea/2026.2/quarkus.icons.quarkusInlay.svg) Add Extensions.

![Quarkus Edit Extensions inlay hint](https://resources.jetbrains.com.cn/help/img/idea/2026.2/quarkus_edit_extensions.png)

3. In the Add Extensions  dialog that opens, select extensions that you want to add.

![Quarkus Edit Extensions dialog](https://resources.jetbrains.com.cn/help/img/idea/2026.2/quarkus_edit_extensions_dialog.png)

Your build file will be modified accordingly. When you add dependencies this way, IntelliJ IDEA considers your Quarkus version, saving you from the need to worry about compatible dependency versions.

You can disable and enable this inlay hint in the IDE settings (`Ctrl+Alt+S` (Windows), `⌘ Comma` (macOS), `⌘ Comma` (IntelliJ IDEA Classic (macOS)), `⌘ Comma` (macOS System Shortcuts), `Ctrl+Alt+S` (XWin), `Ctrl+Alt+S` (GNOME), `Ctrl+Alt+S` (KDE), `Ctrl+Alt+S` (Emacs), `Ctrl+Alt+S` (Sublime Text), `⌘ Comma` (Sublime Text (macOS)), `Ctrl+Alt+S` (NetBeans), `Ctrl+Alt+S` (Visual Studio), `⌘ Comma` (Visual Studio (macOS)), `Ctrl+Alt+S` (Eclipse), `⌘ Comma` (Eclipse (macOS))), in `Editor | Inlay Hints | Other`, under Groovy, Kotlin, and XML.

Procedure: Quickly create a connection to a database

Using the Database Tools and SQL plugin, IntelliJ IDEA lets you create and manage [connections to databases](connecting-to-a-database.html).

In a Quarkus project, you can instantly create it from your application properties file.

1. Open an `application.properties` or `application.yml` file. If it contains datasource-related properties  , the datasource icon ![Datasource icon](https://resources.jetbrains.com.cn/help/img/idea/2026.2/javaee-persistence-impl.icons.expui.add-db-from-config.svg) will be displayed in the gutter.

2. Click ![Datasource icon](https://resources.jetbrains.com.cn/help/img/idea/2026.2/javaee-persistence-impl.icons.expui.add-db-from-config.svg). This will open the data source creation form with datasource parameters (such as URL, username, or database name) populated based on data from your configuration file.

If the data source is already configured, the datasource icon ![](https://resources.jetbrains.com.cn/help/img/idea/2026.2/database-plugin.icons.expui.dbms.svg) is displayed instead. Click it to open the datasource in the Database tool window.

![Create data source window](https://resources.jetbrains.com.cn/help/img/idea/2026.2/quarkus_create_datasource_from_properties.png)

Below is the list of databases for which this action is available:

* Amazon Redshift

* Apache Cassandra

* Apache Derby

* Couchbase

* H2

* HSQLDB

* IBM Db2

* MariaDB

* Microsoft SQL Server

* MongoDB

* MySQL

* Oracle Database

* PostgreSQL

* Redis

* SQLite

* Sybase

For more details on data source parameters, refer to [Data sources](managing-data-sources.html).

Procedure: Debug the Quarkus application

To debug a running Quarkus application, [attach the debugger](attach-to-process.html#attach-to-local) to it.

1. Set a [breakpoint](using-breakpoints.html) in your code.

For example, you can set it on the line with the `return` statement in the `hello()` method.

2. In the main menu, go to `Run | Attach to Process…`.

3. From the list of Java processes, select the process of your Quarkus application.

If successful, IntelliJ IDEA will open the Debug tool window with the established debugger connection.

4. Now open [http://localhost:8080/hello](http://localhost:8080/hello) to call the `hello()` method. The debugger should stop at the breakpoint just before returning the greeting string.

5. In the Debug tool window, click ![the Resume button](https://resources.jetbrains.com.cn/help/img/idea/2026.2/app-client.expui.run.resume.svg) `F9` (Windows), `⌘ ⌥ R` (macOS), `F9` (IntelliJ IDEA Classic (macOS)), `⌃ \` (macOS System Shortcuts), `F9` (XWin), `F9` (GNOME), `F9` (KDE), `F9` (Emacs), `F9` (Sublime Text), `F9` (Sublime Text (macOS)), `F5` (NetBeans), `F5` (Visual Studio), `F5` (Visual Studio (macOS)), `F8` (Eclipse), `F8` (Eclipse (macOS)) to continue the execution and return the string to the web browser.

To detach the debugger, click ![the Stop button](https://resources.jetbrains.com.cn/help/img/idea/2026.2/app-client.expui.run.stop.svg) `Ctrl+F2` (Windows), `⌘ F2` (macOS), `⌘ F2` (IntelliJ IDEA Classic (macOS)), `⌃ ⇧ .` (macOS System Shortcuts), `Ctrl+F2` (XWin), `Ctrl+F2` (GNOME), `Ctrl+2` (KDE), `Ctrl+F2` (Emacs), `Ctrl+F2` (Sublime Text), `Ctrl+F2` (Sublime Text (macOS)), `Shift+F5` (NetBeans), `Shift+F5` (Visual Studio), `⇧ F5` (Visual Studio (macOS)), `Ctrl+F2` (Eclipse), `⌘ F2` (Eclipse (macOS)). This does not stop the actual application process, only detaches the debugger from it.

## Qute

[Qute](https://quarkus.io/guides/qute) is a templating engine for Quarkus. IntelliJ IDEA provides support for Qute, such as code completion, syntax highlighting, finding usages, and more.

For files to be recognized as Qute templates, they must have the `.html`, `.txt`, `.json`, or `.yaml` extension and must be located in the `src/main/resources/templates` folder. Additionally, `*.qute.*` can be used before the extenstion, for example `hello.qute.html`.

Features provided by IntelliJ IDEA include:

* Coding assistance for the Qute syntax. ![Qute syntax completion](https://resources.jetbrains.com.cn/help/img/idea/2026.2/quarkus_qute_syntax_completion.png)

* Completion for the names and methods of declared variables (`Ctrl+Space` (Windows), `⌃ Space` (macOS), `⌃ Space` (IntelliJ IDEA Classic (macOS)), `⌃ Space` (macOS System Shortcuts), `Ctrl+Space` (XWin), `Ctrl+Space` (GNOME), `Ctrl+Space` (KDE), `Alt+/` (Emacs), `Ctrl+Space` (Sublime Text), `⌃ Space` (Sublime Text (macOS)), `Ctrl+Space` (NetBeans), `Ctrl+Space` (Visual Studio), `⌃ Space` (Visual Studio (macOS)), `Ctrl+Space` (Eclipse), `⌃ Space` (Eclipse (macOS))), and navigation to their declarations (`Ctrl+B` (Windows), `⌘ B` (macOS), `⌘ B` (IntelliJ IDEA Classic (macOS)), `⌘ B` (macOS System Shortcuts), `Ctrl+B` (XWin), `Ctrl+B` (GNOME), `Ctrl+B` (KDE), `Ctrl+Alt+G` (Emacs), `F12` (Sublime Text), `F12` (Sublime Text (macOS)), `Ctrl+B` (NetBeans), `F12` (Visual Studio), `F12` (Visual Studio (macOS)), `F3` (Eclipse), `F3` (Eclipse (macOS))). ![Qute variable completion](https://resources.jetbrains.com.cn/help/img/idea/2026.2/quarkus_qute_variable_completion.png)

* Live templates: Type `q` and press `Ctrl+Space` (Windows), `⌃ Space` (macOS), `⌃ Space` (IntelliJ IDEA Classic (macOS)), `⌃ Space` (macOS System Shortcuts), `Ctrl+Space` (XWin), `Ctrl+Space` (GNOME), `Ctrl+Space` (KDE), `Alt+/` (Emacs), `Ctrl+Space` (Sublime Text), `⌃ Space` (Sublime Text (macOS)), `Ctrl+Space` (NetBeans), `Ctrl+Space` (Visual Studio), `⌃ Space` (Visual Studio (macOS)), `Ctrl+Space` (Eclipse), `⌃ Space` (Eclipse (macOS)) to view available Qute live templates. ![Qute live templates](https://resources.jetbrains.com.cn/help/img/idea/2026.2/quarkus_qute_live_templates.png) To configure Qute [live templates](using-live-templates.html) or create new ones, open the IDE settings (`Ctrl+Alt+S` (Windows), `⌘ Comma` (macOS), `⌘ Comma` (IntelliJ IDEA Classic (macOS)), `⌘ Comma` (macOS System Shortcuts), `Ctrl+Alt+S` (XWin), `Ctrl+Alt+S` (GNOME), `Ctrl+Alt+S` (KDE), `Ctrl+Alt+S` (Emacs), `Ctrl+Alt+S` (Sublime Text), `⌘ Comma` (Sublime Text (macOS)), `Ctrl+Alt+S` (NetBeans), `Ctrl+Alt+S` (Visual Studio), `⌘ Comma` (Visual Studio (macOS)), `Ctrl+Alt+S` (Eclipse), `⌘ Comma` (Eclipse (macOS))) and go to `Editor | Live Templates | Qute`.

Procedure: Navigate to Qute templates

IntelliJ IDEA enables quick navigation to Qute templates from locations in your code where they are referenced.

1. Open the section of code where you have referenced a Qute template.

This can be a class annotated with `@CheckedTemplate`, a record that implements `io.quarkus.qute.TemplateInstance`, or an injected template.

2. In the gutter, click ![](https://resources.jetbrains.com.cn/help/img/idea/2026.2/app-client.expui.fileTypes.anyType.svg) (Navigate to Qute template).

![Navigate to Qute](https://resources.jetbrains.com.cn/help/img/idea/2026.2/quarkus_navigate_to_template.png)

If the relevant Qute template exists, it will be opened in the new editor tab. IntelliJ IDEA takes into account the `@Location` annotation and the `basePath` attribute when determining the template location.