Build-Time Augmentation (AOT): All dependency injection wiring, configuration binding, and bytecode optimizations occur at build time, eliminating runtime reflection and slow dynamic class loading.
Unified Reactive Core: Eclipse Vert.x single event loop handles non-blocking IO with HTTP/3 & io_uring support underneath both imperative and reactive code.
Dual Execution Modes: Seamless deployment into Standard JVM Mode (optimized for Java 17/21+ Virtual Threads) or GraalVM Native Image (0.01s boot time and ~30MB memory footprint).
Traditional Frameworks: Like a restaurant that waits until the customer walks in the door to mix the flour, knead the dough, and bake the bread from scratch.
Quarkus: Pre-bakes the bread at the factory (Build-Time Augmentation). When the customer arrives (Runtime Boot), it only needs to turn on the warming tray.
In Quarkus 3.x, the entire ecosystem migrated from javax.* to jakarta.* following Jakarta EE 10:
Specification
Old Package (Quarkus 2.x)
New Package (Quarkus 3.x)
REST APIs (JAX-RS)
javax.ws.rs.*
jakarta.ws.rs.*
CDI (Dependency Injection)
javax.enterprise.*, javax.inject.*
jakarta.enterprise.*, jakarta.inject.*
Persistence (JPA)
javax.persistence.*
jakarta.persistence.*
Bean Validation
javax.validation.*
jakarta.validation.*
Servlets
javax.servlet.*
jakarta.servlet.*
[!WARNING]
Gotcha Alert: JDK-native packages such as javax.net.ssl, javax.crypto.*, and javax.sql.* are part of the Java Standard Library and remain javax.*. Do not rename them!
[!NOTE]
Quarkus Update Tool: Automates 90%+ of package renames using OpenRewrite:
Unified Engine: Handles both blocking and non-blocking workloads automatically. If your method returns a reactive Uni/Multi, it stays on the event loop; if it’s traditional blocking, Quarkus routes it to a worker thread or Virtual Thread.
HTTP/3 Support: Native QUIC protocol support fixes head-of-line blocking over UDP.
Linux io_uring: High-performance asynchronous kernel I/O ring buffer.
💉 ArC CDI Container (CDI):
CDI Lite: Jakarta EE 10 standardized subset of CDI designed specifically for ahead-of-time (AOT) compilation.
Build Compatible Extensions (BCE): Replaces heavy runtime portable extensions with extensions that run during compilation.
Zero Runtime Reflection: All bean injection graphs, interceptors, and proxies are generated into raw bytecode at build time.
Built-in OpenID Connect (OIDC) and JSON Web Tokens (JWT).
Declarative Role-Based Access Control (RBAC) using standard @RolesAllowed, @Authenticated, and @PermitAll.
Unified configuration prefix: quarkus.oidc.*.
📊 MicroProfile 6 & OpenTelemetry (OBS):
OpenTelemetry Standard: Fully replaced legacy OpenTracing. Configuration namespace is unified under quarkus.otel.*.
Admin Network Interface: Allows binding management endpoints (/q/health, /q/metrics) to an isolated port or internal network interface separate from public HTTP traffic.
/q/info: Exposes build and application git metadata.
Jandex Pre-Indexing: Reads bytecode and builds an offline indexed catalog of classes, methods, and annotations.
Bytecode Transformation (ASM): Inlines dependency injection calls directly into bytecode, removing the need for runtime reflection.
Build Compatible Extensions (BCE): Executes extension code during compilation to register synthetic beans and observers.
Static Initialization & Pre-Recording: Executes static blocks, initializes JPA entity metamodels, and bakes routing tables directly into static class state recorded into the binary.
Engine: Substrate VM Ahead-Of-Time (AOT) compiler.
Closed-World Assumption: Everything the application will ever execute must be discoverable and compiled at build time. Dynamic code generation and unconfigured reflection are removed.
Metrics: ~0.01s boot time, 25–35 MB RSS memory footprint.
Best for: Serverless (AWS Lambda, Google Cloud Run), scale-to-zero microservices, and Kubernetes ephemeral jobs.
UBI 9 Default: Red Hat Universal Base Image 9 is now the default builder and runtime container image in Quarkus 3.x (replacing UBI 8).
Linux io_uring Kernel Acceleration: Replaces traditional epoll system calls with dual shared memory rings between userland and the Linux kernel, minimizing context switches.
Container & Kubernetes / OpenShift Native: Pre-optimized images and zero-config Kubernetes manifests for seamless cloud-native deployments.
Test your understanding before expanding each card.
1. What is the single biggest breaking change for developers migrating to Quarkus 3.x?
Answer: The Jakarta EE 10 migration. All javax.* packages (JAX-RS, CDI, JPA, Bean Validation, Servlets) were renamed to jakarta.*. The migration is largely automated using quarkus update --stream=3.0.
2. Are all javax.* packages renamed to jakarta.* in Quarkus 3.x?
Answer:No. JDK standard library packages like javax.crypto.*, javax.net.ssl.*, and javax.sql.* remain javax.* because they are part of the Java SE runtime, not Jakarta EE.
3. Why does Quarkus start in milliseconds while traditional frameworks take seconds?
Answer: Quarkus shifts heavy framework operations (classpath scanning, annotation reflection parsing, and proxy generation) from runtime boot to compile time via its Build-Time Augmentation Engine. At runtime, it only loads pre-recorded bytecode.
4. What is the purpose of CDI Lite in Quarkus 3.x?
Answer: CDI Lite is a standardized lightweight subset of CDI introduced in Jakarta EE 10. It replaces runtime-heavy portable extensions with Build Compatible Extensions (BCE), enabling fast build-time analysis and zero-reflection dependency injection.
5. How does RESTEasy Reactive handle blocking database calls?
Answer: RESTEasy Reactive inspects method signatures at build time. If a method returns a reactive type (Uni/Multi), it executes directly on the non-blocking Vert.x event loop. If it performs blocking I/O (like traditional JDBC), Quarkus automatically offloads it to a worker thread pool or a Virtual Thread.
6. What is the “Closed-World Assumption” in GraalVM Native Image?
Answer: All code, classes, methods, and reflection metadata that can possibly be called at runtime must be known at build time. GraalVM analyzes the entire call graph and removes unreachable bytecode, producing a minimal native binary.
7. Why did Quarkus 3.x upgrade its default base image to UBI 9?
Answer: Red Hat Universal Base Image 9 (UBI 9) provides modern glibc compatibility, security fixes, and Linux kernel feature support (such as io_uring) while succeeding the aging UBI 8 lifecycle.
8. When should you choose Standard JVM Mode over GraalVM Native Image?
Answer:
Choose JVM Mode: For long-running microservices where high peak throughput and JIT optimizations matter most, or when relying on dynamic class loading / reflection libraries.
Choose Native Mode: For serverless functions (AWS Lambda), scale-to-zero workloads, or high-density containers where sub-50ms startup time and minimal memory footprint (~30MB) are critical.
“Quarkus 3.x is a Kubernetes-native Java framework that fundamentally changes Java’s operational profile. By shifting classpath scanning, dependency injection, and reflection elimination to build time through its Build-Time Augmentation pipeline, it achieves sub-second boot times and minimal memory footprint.
Underneath, it unifies Jakarta EE 10 standards on top of an Eclipse Vert.x reactive event loop, natively supporting both blocking and non-blocking code with HTTP/3 and io_uring. Finally, it offers a seamless choice between Java 21 Virtual Threads on HotSpot for peak throughput, and GraalVM Native Image for instant serverless execution.”
Quarkus’s ultra-lightweight Dependency Injection (CDI) engine. Unlike traditional CDI containers (e.g., Weld) that scan and reflect on classes at boot, ArC analyzes all @Inject, bean scopes, and interceptors at build time, generating static bytecode with zero runtime reflection.
CDI
Contexts and Dependency Injection
The official enterprise Java specification for dependency injection (handling @Inject, @ApplicationScoped, @Produces, @Observes, etc.). Enables clean, decoupled architecture between components.
CDI Lite
CDI Lite (Jakarta EE 10 Standard)
A streamlined subset of CDI introduced in Jakarta EE 10 specifically designed for ahead-of-time (AOT) compilation. It removes runtime-only reflection features so frameworks like Quarkus can inspect all beans at build time.
BCE
Build Compatible Extensions
The new extension mechanism in CDI Lite. Replaces heavy runtime “portable extensions” with compile-time extensions, allowing Quarkus extensions to register beans and transform types during build.
SmallRye
SmallRye Project
An open-source collection of implementations of the Eclipse MicroProfile specifications (e.g., SmallRye Config, SmallRye Reactive Messaging, SmallRye Health). Quarkus leverages SmallRye as foundational building blocks for cloud-native APIs.
Vert.x
Eclipse Vert.x
The high-performance reactive toolkit at the core of Quarkus. It provides an event-driven Netty Event Loop that multiplexes network traffic over a tiny pool of OS threads, handling tens of thousands of concurrent connections.
Netty
Netty Asynchronous Event-Driven Network Framework
The low-level non-blocking I/O network engine that powers Vert.x and Quarkus, handling raw TCP, HTTP/1/2/3, and WebSocket sockets with zero-copy buffer pooling.
Mutiny
Mutiny Reactive Programming Library
Quarkus’s event-driven reactive stream library built on Uni (0 or 1 item) and Multi (0 to N streaming items). Replaces confusing reactive pipelines with readable, intuitive, chainable APIs.
RESTEasy Reactive
RESTEasy Reactive REST Framework
The default HTTP/REST engine in Quarkus. It maps JAX-RS endpoints directly onto the Vert.x event loop, handling reactive methods non-blockingly and automatically routing blocking methods to worker threads or Virtual Threads.
Jandex
Java Annotation Indexer
A build-time tool that scans .class files in your project and dependencies, producing a compact offline binary index of all classes, methods, and annotations so Quarkus never has to scan the classpath at runtime.
ASM
Java Bytecode Manipulation & Analysis Framework
The low-level bytecode library Quarkus uses at build time to rewrite bytecode, inline dependency injection calls, remove reflection, and generate synthetic classes.
AOT
Ahead-of-Time Compilation
Performing compilation, optimization, class analysis, and bean wiring before the application runs (at build time) instead of doing it lazily when the application starts up.
GraalVM
GraalVM & Substrate VM
An advanced JDK that can compile Java bytecode directly into a standalone, OS-native machine executable (Native Image) with sub-10ms startup times and no standard JVM requirement.
OpenTelemetry (OTel)
OpenTelemetry
The industry-standard CNCF observability framework for distributed tracing and metrics, replacing legacy OpenTracing and Jaeger client libraries in Quarkus 3.x.
OIDC
OpenID Connect
An identity and authentication standard built on top of OAuth 2.0. Quarkus provides built-in OIDC support for enterprise identity providers (Keycloak, Auth0, Okta, Azure AD).
JWT
JSON Web Token
A compact, cryptographically signed token format used to transmit authenticated claims between microservices, supported natively in Quarkus via MicroProfile JWT.
io_uring
Linux Kernel io_uring Asynchronous I/O
A high-performance Linux kernel interface that uses dual shared memory ring buffers between user space and the kernel, eliminating costly epoll context switches for socket and file I/O.
UBI
Universal Base Image (Red Hat UBI 9)
Enterprise-grade, hardened Linux container base images provided by Red Hat, used as the default base operating system layer for Quarkus container builds.
Virtual Threads (Loom)
Java Virtual Threads (Project Loom)
Lightweight JVM-managed threads (introduced in Java 21) that allow developers to write simple, synchronous blocking code while the JVM scales to millions of concurrent virtual threads without exhausting OS threads.
MicroProfile
Eclipse MicroProfile
An open set of enterprise Java specifications tailored for cloud-native microservices (Health, Metrics, Fault Tolerance, Config, OpenAPI), implemented in Quarkus primarily via SmallRye.
