You’re Only Using Half of Quarkus: 10 Hidden Features That Change Everything

Discover what most Java developers miss—AI assistants, dynamic Qute templates, auto-refreshing tokens, and reactive magic.

Most developers know Quarkus for its instant startup and live reload. But beyond those flagship features, the framework hides a deep collection of small, powerful capabilities that quietly elevate your daily workflow. These are the features that rarely make it into release highlights, but once you discover them, you’ll never go back.

Let’s explore ten hidden gems that deserve your attention.

Chappie — Your AI Pair Programmer in Dev Mode

Sources: Quarkus 3.24 Release Notes | Quarkiverse Chappie Extension

Starting with Quarkus 3.24, you can add an AI-powered assistant directly into your Dev UI. Chappie isn’t just another remote chatbot. It runs alongside your live app, with full context of your project.

quarkus ext add io.quarkiverse.chappie:quarkus-chappie

Once enabled, open the Dev UI (/q/dev-ui) and you’ll see Chappie appear. It can:

• Generate boilerplate code following your existing project structure

• Explain configuration options and annotations

• Suggest fixes for compile-time errors

• Answer “what does this class do?” based on your actual code

Extensions can even contribute their own Chappie capabilities, making it smarter as your tech stack grows. A genuine pair-programmer for Quarkus developers.

Dev MCP — Let Claude Control Your App

Source: Quarkus 3.26 CR1 Release Notes

Quarkus 3.26 quietly introduced Model Context Protocol (MCP) support. This turns your running Dev UI into a live API that AI tools can call.

That means you can literally ask Claude or ChatGPT:

“Check my Quarkus logs”
“Trigger a hot reload”
“List installed extensions”

…and it will perform those actions via the MCP bridge.

# Runs MCP automatically in dev mode
mvn quarkus:dev

This bridges the gap between conversational AI and your development environment. For the first time, AI assistants can actually use your app, not just talk about it. You can read more about it in a separate article.

Dev UI HQL Console with Hibernate Assistant

Source: PR #49165

The Dev UI’s HQL console got a full redesign in Quarkus 3.26. It now includes syntax highlighting, auto-completion, query history, and a Hibernate Assistant that guides you as you type.

Go to
http://localhost:8080/q/dev-ui → Hibernate ORM → HQL Console

Try:

SELECT p FROM Product p
WHERE p.category.name = :category
ORDER BY p.price DESC

The assistant can suggest indexes, warn about N+1 queries, and even explain query plans: All before you hit production. A must-try tool for anyone using Panache or ORM.

JFR Extension — Production-Grade Profiling

Source: PR #48687

Performance profiling used to mean external APM tools or heavy JVM agents. Quarkus 3.26 integrates Java Flight Recorder (JFR) natively for production-safe telemetry.

<dependency>
  <groupId>io.quarkus</groupId>
  <artifactId>quarkus-jfr</artifactId>
</dependency>

You’ll capture:

• HTTP request traces and durations

• Database query timings

• Memory allocation and GC metrics

• Thread contention points

It’s the same level of insight you’d expect from paid monitoring tools without the overhead.

Offline Hibernate Startup

Source: PR #49408

If your app fails to start because the database isn’t ready, this one’s for you. Quarkus 3.26 allows Hibernate to skip its startup connection attempt.

quarkus.hibernate-orm.database.offline=true
quarkus.hibernate-orm.database.generation=none

Your service now boots instantly, even if PostgreSQL is still initializing. Ideal for:

• Kubernetes pods with init containers

• Cloud environments with lazy resource provisioning

• Local development with Dev Services

Once the database is up, Hibernate connects automatically on first query.

Dynamic Qute Template Includes

Source: PR #48433

Qute templates can now include partials dynamically at runtime.

{#include template=computedTemplateName /}

@TemplateExtension
static String computedTemplateName(UserContext ctx) {
    return ctx.isMobile() ? “footer-mobile” : “footer-desktop”;
}

You can pick templates based on device, locale, or theme, without polluting your markup with conditionals. It’s a subtle change that makes Qute dramatically more flexible.

OIDC Token Auto-Refresh on 401

Source: PR #49003

Your REST clients can now handle token expiration transparently. The OIDC client filter automatically refreshes tokens when it encounters a 401 response.

quarkus.oidc-client.refresh-token-time-skew=10s
quarkus.rest-client.my-api.oidc-client-filter.auto-refresh-on-401=true

The flow is automatic:

1. Request fails with 401

2. Filter refreshes the token

3. Retry occurs silently

No extra code, no retries in your business logic, just reliable, secure calls.

Zip File Support in SQL Import Scripts

Source: PR #47338

You can now ship your SQL import scripts as a single ZIP file.

quarkus.hibernate-orm.sql-load-script=import-data.zip

Inside the archive you can include multiple .sql files, environment-specific datasets, or large fixture data. Quarkus extracts and executes them automatically at startup. Perfect for integration tests or demo environments.

@RegisterResourceBundle for Native Images

Source: PR #48805

Native image configuration can now be done directly in code.

@RegisterResourceBundle(”messages”)
@RegisterResources(patterns = “data/.*\\.json”)
public class MyConfig {
}

No more editing resource-config.json or reflection files by hand. The compiler picks up these annotations and includes the necessary resources automatically. A small feature that saves hours during native builds.

Dev UI Settings Persistence

Source: PR #49496

The Dev UI now remembers your settings and command history per project.

You’ll keep:

• Console command history (HQL, GraphQL, etc.)

• Dev Services configurations

• Theme and layout preferences

• Recent test data and queries

Each Quarkus project maintains its own workspace state, so switching between apps doesn’t reset your environment. It’s the kind of polish that shows how much Quarkus values developer experience.

Bonus: Named Persistence Units in Hibernate Reactive

📘 Source: PR #48007

Finally: Multiple persistence units in Hibernate Reactive. You can now define and inject separate reactive session factories.

quarkus.datasource.users.db-kind=postgresql
quarkus.datasource.products.db-kind=postgresql

quarkus.hibernate-orm.users.datasource=users
quarkus.hibernate-orm.products.datasource=products

@Inject
@PersistenceUnit(”users”)
Mutiny.SessionFactory usersFactory;

@Inject
@PersistenceUnit(”products”)
Mutiny.SessionFactory productsFactory;

This unlocks true multi-database reactive microservices, without resorting to low-level drivers.

Quarkus’s biggest innovations aren’t always the loudest.

Features like Chappie, Dev MCP, and persistent Dev UI settings reflect a framework that constantly improves the everyday life of Java developers.

While benchmarks grab the headlines, it’s these thoughtful details that make Quarkus feel modern, responsive, and deeply developer-centric.

Which of these hidden gems surprised you most?
Drop a comment below or better yet, open your Dev UI and see how many you’ve already been using without noticing.

Check the Quarkus release notes regularly. There’s always another hidden treasure waiting.