Developer Productivity Suite for Quarkus

Quarkus Studio supercharges your Quarkus workflow inside Visual Studio Code. Designed for both single-module and complex multi-module enterprise architectures, Quarkus Studio brings real-time Dev Mode orchestration, intelligent Dev Services container management, dynamic port resolution, and direct access to developer tools right from the Activity Bar.

I have furnished a detailed learning resource at : quarkus-studio.github.io

✨ Features

Project Builder

1. 📂 Apps View

Gain complete visibility and control over single-module and multi-module Quarkus workspaces directly in the Quarkus Studio sidebar.

• Single & Multi-Module Workspace Detection: Automatically identifies Maven root POMs (<modules>) and Gradle settings.gradle / settings.gradle.kts configurations, mapping submodules hierarchically.
• Accurate Submodule Naming: Accurately resolves individual child module artifactIds in multi-module POMs (bypassing parent <parent><artifactId> ambiguities).
• Service Status & Play Icons:
  • Clean, dedicated play icons for every runnable Quarkus app:
    • Stopped: Outline play icon (ThemeIcon('play')) with inline Start Dev Mode action.
    • Running: Solid filled green play icon (ThemeIcon('debug-start')) with inline Stop, Restart, View Logs, and Open Dev UI actions.
• One-Click Dev Mode Lifecycle: Start, stop, and restart Dev Mode (./mvnw compile quarkus:dev, ./gradlew quarkusDev) per service with a dedicated integrated terminal.
• Dynamic Dev UI Launcher: Reads quarkus.http.port from application.properties (e.g. port 8081) to automatically route the Open Dev UI action to the exact running endpoint (e.g. http://localhost:8081/q/dev-ui), falling back to http://localhost:8080/q/dev-ui.
• Endpoints Explorer: Automatically discovers all REST endpoints (@Path, @GET, @POST, @PUT, @DELETE, @PATCH, and Spring Web mappings) in Java and Kotlin source files under an Endpoints tree node:
  • Jump to Source: Click any endpoint to jump directly to the handler method in the editor.
  • Method Badges: Color-coded HTTP verbs (GET, POST, PUT, DELETE, PATCH).
  • Inline Actions: One-click to Open in Browser, Copy Endpoint URL, or Copy Endpoint Path.
  • Generate Postman Collections: Right-click the Endpoints node to export all detected REST endpoints into a Postman Collection v2.1.0 JSON file (AppName-<date>.postman_collection.json) under the project root/postman folder with folder grouping by resource class, path variables, request headers, bodies, and configurable baseUrl.
  • Live Sync: Watches **/*.{java,kt} to refresh endpoints dynamically as you write code.
• Clean Tree Presentation: Focused, uncluttered view displaying configuration files (application.properties / application.yaml) and build files (pom.xml, build.gradle) with instant click-to-open access.

2. 🐳 Dev Services Visualizer

Effortlessly monitor, manage, and connect to background Quarkus Dev Services and active container dependencies.

• Docker & Podman Support: Seamless compatibility with both Docker Desktop and Podman, with auto-detection or manual runtime configuration (quarkusStudio.containerRuntime).
• Comprehensive Service Recognition: Automatically detects and categorizes containers for:
  • Databases: PostgreSQL, MySQL, MariaDB, Oracle, Microsoft SQL Server, MongoDB.
  • Brokers & Messaging: Apache Kafka, RabbitMQ.
  • Caches & Storage: Redis, OpenSearch, Elasticsearch.
  • Security & Identity: Keycloak, HashiCorp Vault.
  • Testing & Emulation: LocalStack, WireMock, Mailpit.
• Smart Container Filtering: Intelligently surfaces active service and database containers while filtering out maintenance sidecars (such as testcontainers/ryuk) and proxy gateways.
• One-Click Container Control: Stop, restart, or inspect individual containers directly from the sidebar.
• Live Container Logs: Stream real-time container output (docker logs -f) into dedicated VS Code output channels with auto-scroll.
• One-Click Connection String Copy: Copy ready-to-use connection strings and JDBC URLs to your clipboard:
  • jdbc:postgresql://localhost:<port>/quarkus
  • jdbc:mysql://localhost:<port>/quarkus
  • redis://localhost:<port>
  • localhost:<port> (Kafka Bootstrap Servers)
  • amqp://guest:guest@localhost:<port>
• Web Console Launcher: Launch web management interfaces (Keycloak Admin Console, Mailpit Web UI, RabbitMQ Management) in your default browser with a single click.
• Quick Dev Mode Bootstrap: Launch Quarkus Dev Mode from the Dev Services view header to immediately provision missing containers.

3. ⚙️ Smart application.properties Config Assistant

Supercharge Quarkus configuration with in-editor intelligence, build-time safety checks, and real-time cloud deployment cost estimates.

• code.quarkus.io Integration & Catalog:
  • Directly synchronizes with the code.quarkus.io extension registry (/api/extensions) to discover extension metadata, guides, and custom configuration keys.
  • Bundles a high-performance offline catalog covering Quarkus Core, Hibernate ORM, RESTEasy Reactive, Agroal Datasource, Redis, Kafka, OIDC, Security, Virtual Threads, and Cloud/Serverless extensions.
  • Automatically analyzes project dependencies (pom.xml / build.gradle) to prioritize configurations for installed extensions.
  • Command: Quarkus Studio: Reload Config Metadata (quarkus-studio.configAssistant.reload).
• Contextual & Profile-Aware Autocompletion:
  • Full property key completion with Markdown documentation, phase tags ([🔒 Build Time] vs [⚙️ Runtime]), default values, and types.
  • Seamless support for environment profiles: %dev., %test., %prod., %staging..
  • Value autocompletion after = for enums (e.g. postgresql, mysql, fast-jar, native) and boolean flags (true, false).
• Build-Time Fixed Property Diagnostics & Quick-Fixes:
  • In Quarkus, properties marked as build-time fixed (e.g. quarkus.package.type, quarkus.datasource.db-kind, quarkus.hibernate-orm.database.generation) cannot be dynamically modified at runtime.
  • Flags invalid runtime overrides (such as %prod.quarkus.datasource.db-kind=...) with clear in-editor diagnostic warnings.
  • One-click Quick Fix (Remove '%prod.' prefix) to safely configure properties globally for the build phase.
• Inline Cloud Cost & Resource Footprint Estimates:
  • Inlay Hints: Displays live memory, cold start, and serverless pricing badges directly in application.properties:
    • quarkus.package.type=native ➔ 💡 [Cloud Est: ~32MB RSS | Cold start <25ms | Lambda: ~$0.25/1M]
    • quarkus.package.type=fast-jar ➔ 💡 [Cloud Est: ~192MB RSS | Cold start ~1.5s | Lambda: ~$0.83/1M]
    • quarkus.virtual-threads.enabled=true ➔ 💡 [Loom: ~90% lower thread memory per req]
    • quarkus.datasource.jdbc.max-size=25 ➔ 💡 [Pool Buffer: ~50MB RAM | 25 conns]
  • Rich Hover Tooltips: Hover over any property to inspect detailed comparison tables comparing GraalVM Native vs OpenJDK JVM footprints, AWS Lambda invocation costs, Google Cloud Run pay-per-use, and Kubernetes pod density.
  • Full Cloud Report: Run Quarkus Studio: Show Cloud Cost & Resource Estimates (quarkus-studio.configAssistant.showCostEstimates) to output a comprehensive deployment sizing report.

4. ⚡ Panache Entity & DTO Generator

Instantly generate production-grade Hibernate with Panache or MongoDB with Panache entities, Java 17+ Record DTOs, companion repositories, and full CRUD REST endpoints with a single right-click or command.

• Multiple Input Sources:
  • Contextual Right-Click Menus: Right-click any Java package folder, .java file, .json payload, or .sql / .ddl migration script in the Explorer or active editor.
  • Interactive Wizard: Prompts for entity name, field definitions (name:String, price:BigDecimal, inStock:Boolean), and architecture preferences.
  • JSON Payload Inference: Automatically infers Java types from JSON samples (e.g. integer vs decimal/BigDecimal, ISO dates to LocalDate/LocalDateTime, UUIDs, booleans, and arrays).
  • SQL / DDL Schema Parser: Parses CREATE TABLE DDL statements, maps SQL types (VARCHAR, BIGSERIAL, DECIMAL, TIMESTAMP, BOOLEAN) to Java types, extracts primary keys, and converts snake_case columns to camelCase properties with @Column(name = "...") and @Table(name = "...").
• Flexible Architectural Patterns:
  • Active Record Pattern (Recommended for Quarkus):
    • Extends PanacheEntity (with inherited public Long id;) or PanacheEntityBase (for custom UUID / String IDs).
    • Public fields enhanced at build-time with idiomatic Quarkus bytecode transformation.
    • Generates static finder helper methods (e.g. findByName(String name)).
  • Repository Pattern (DDD / Clean Architecture):
    • Generates standard @Entity class with primary key annotations.
    • Generates companion @ApplicationScoped repository implementing PanacheRepository<Entity> with custom query helpers.
• Dual Persistence Backends:
  • Hibernate ORM with Panache: Tailored for PostgreSQL, MySQL, MariaDB, Oracle, SQL Server, and H2 with @Entity, @Table, @Column, and @Transactional.
  • MongoDB with Panache: Generates @MongoEntity(collection = "..."), ObjectId ID mappings, and PanacheMongoEntity / PanacheMongoRepository.
• Modern Java 17+ Record DTOs:
  • Generates immutable Java record DTOs for safe API transport.
  • Includes bidirectional conversion helper methods:
    • fromEntity(Entity entity): Static factory mapping entity to DTO.
    • toEntity(): Instantiates and maps DTO to fresh entity.
    • updateEntity(Entity entity): Applies DTO mutation to existing managed entity.
• Complete JAX-RS / Quarkus REST CRUD Endpoints:
  • Automatically scaffolds REST resources under @Path("/api/<entities>") with @Produces and @Consumes(MediaType.APPLICATION_JSON):
    • GET /api/<entities>: Returns full list mapped to DTOs.
    • GET /api/<entities>/{id}: Returns 200 OK or 404 Not Found.
    • POST /api/<entities>: @Transactional create endpoint returning 201 Created with Location header.
    • PUT /api/<entities>/{id}: @Transactional update endpoint returning 200 OK or 404 Not Found.
    • DELETE /api/<entities>/{id}: @Transactional delete endpoint returning 204 No Content.
• Automatic Package & Directory Resolution:
  • Automatically identifies src/main/java root and derives the appropriate Java package name.
  • Creates files directly in the target directory and immediately opens the generated entity in the editor.

5. 🧪 Live Testing & Continuous Feedback HUD

Supercharge test-driven development with deep Quarkus Continuous Testing integration, real-time code gutter indicators, instant rerun of failed tests on save, and interactive test profile switching.

• Seamless Continuous Testing Integration:
  • Automatically interfaces with Quarkus Dev Mode's continuous testing engine.
  • Sends direct keystrokes to active Dev Mode terminals (r to rerun all, f to rerun failed, p to pause, t to toggle, o to view output).
  • Listens to Surefire, Failsafe, and Gradle JUnit XML reports in real-time to synchronize test state instantly without manual terminal switching.
• In-Editor Code Gutter Indicators:
  • 🟢 Passing Tests: Clean green check indicator beside passing @Test and @ParameterizedTest methods.
  • 🔴 Failing Tests: High-visibility red error indicator in the editor gutter for failing test methods.
  • ⚪ Skipped & 🔄 Running Indicators: Real-time indicators showing skipped or currently executing tests.
  • Rich Markdown Failure Tooltips: Hover over any failing test gutter icon to inspect execution duration, failure messages, and complete Java stack traces directly in the editor.
• Instant Failed Test Rerun on Save:
  • Automatically triggers a rapid re-run of failed tests (f) as soon as you save any .java or configuration file (application.properties).
  • If a test class (*Test.java) is saved, immediately targets and executes tests in that class.
  • Configurable via quarkusStudio.continuousTesting.rerunOnSave.
• Continuous Feedback HUD in Status Bar:
  • Live status item in the VS Code status bar:
    • $(pass-filled) Quarkus Tests: 12 passed
    • $(error) Quarkus Tests: 2 failed (10 passed)
    • $(sync~spin) Quarkus Tests: running...
    • $(debug-pause) Quarkus Tests: paused
  • Click-to-Action Quick Menu: Click the status bar HUD to instantly rerun all tests, rerun failed tests, pause/resume testing, switch test profiles, or jump to the test terminal.
• Interactive Test Profile Swapper (@TestProfile):
  • Automatically scans your workspace for classes implementing io.quarkus.test.junit.QuarkusTestProfile.
  • Open any test class and trigger Switch Test Profile (@TestProfile):
    • Select from all discovered test profiles in your workspace.
    • Automatically updates or inserts @TestProfile(MyProfile.class) onto the test class.
    • Automatically manages package imports (import io.quarkus.test.junit.TestProfile;).
    • Option to Remove @TestProfile to revert to default configuration.
    • Option to Create New QuarkusTestProfile... to scaffold a custom test profile class with getConfigOverrides() and imports.
• Sidebar Continuous Testing Tree View:
  • Dedicated Continuous Testing tree view under the Quarkus Studio activity bar container.
  • Displays overall test suite execution state, active @TestProfile, and hierarchical view of test classes and test methods.
  • Color-coded icons, execution duration badges, and full failure tooltips on test case nodes.
  • Jump to Source: Click any test method in the tree to jump directly to its definition in the Java editor.
  • Inline Action Buttons: Header actions to Rerun All Tests, Rerun Failed Tests, Toggle/Pause Continuous Testing, Switch Test Profile, and Refresh.
• In-Editor CodeLens Actions:
  • ▶ Run Test: Execute any single test method directly above its declaration.
  • ❌ Rerun Failed (<time>ms): Highlights failed tests with direct one-click rerun.
  • ▶ Run Tests in <Class> & 🏷 Profile: ...: Class-level CodeLens to execute all tests in class or swap test profile.

6. ✂️ Quarkus Studio Snippets (qs-)

Boost your daily Quarkus development speed with a curated, comprehensive collection of context-aware snippets for configuration files and Java source code. All snippets share the uniform qs- prefix—simply type qs or qs- in any supported file to view immediate suggestions.

• Language-Specific Scoping:
  • application.properties: Ready-to-use blocks for PostgreSQL/MySQL/Oracle datasources, Reactive Vert.x clients, Hibernate ORM, MongoDB, Redis, Kafka Reactive Messaging, OIDC/Keycloak, OpenAPI/Swagger UI, GraalVM Native flags, and profile overrides (%dev, %prod, %test).
  • application.yaml: Full Quarkus hierarchical YAML configuration templates.
  • Java (*.java):
    • Full File Scaffolding: Panache Active Record entities (extends PanacheEntity), standard JPA entities, Panache repositories (PanacheRepository<T>), MongoDB Panache entities/repositories, complete JAX-RS CRUD resources with pagination and validation, Java 17+ Record DTOs, custom Bean Validation constraints, @QuarkusTest suites, @TestProfile implementations, scheduled jobs, startup/shutdown observers, and Kafka reactive messaging consumers/producers.
    • Quarkus & CDI Annotations: @Transactional, @ApplicationScoped, @Blocking, @NonBlocking, @RunOnVirtualThread (Loom), @RolesAllowed, @Fallback, @Retry, @CircuitBreaker, @ConfigProperty, and more.
    • REST Endpoints: @GET, @POST, @PUT, @DELETE, @PATCH, and Server-Sent Events (SSE) stream methods.
    • Panache Operations: Quick expressions for listAll(), findByIdOptional(), parameterized find(), persist(), deleteById(), count(), and bulk updates.
    • Bean Validation: Inline constraint annotations (@NotBlank, @NotNull, @Size, @Min, @Max, @Email, @Pattern, @Positive, @Valid).
    • Common Dev Patterns & Logging: Fast static logging via io.quarkus.logging.Log (qs:log-info, qs:log-error, qs:log-warn, qs:log-debug), programmatic JTA transactions (qs:tx-run), Mutiny reactive streams, and try-catch error blocks.

✂️ Quarkus Studio Snippets Reference

All snippets use the prefix qs- (Quarkus Studio). Type qs in your editor to trigger IntelliSense.

1. ⚙️ application.properties Snippets

2. 📄 application.yaml Snippets

3. 🏗️ Java File Generator Snippets (*.java)

Generate full, compilable class files with correct packages, imports, and best-practice Quarkus patterns:

4. 🏷️ Quarkus & CDI Annotation Snippets (*.java)

5. 🌐 REST Endpoints & Methods Snippets (*.java)

6. 🗄️ Panache Operations & Query Snippets (*.java)

7. 🛡️ Jakarta Bean Validation Snippets (*.java)

8. 📝 Common Dev Patterns & Logging Snippets (*.java)

Quarkus provides a fast, zero-allocation static logging API via io.quarkus.logging.Log. These snippets can be triggered using either qs: (e.g. qs:log-info) or qs- (e.g. qs-log-info):

📋 Requirements & Dependencies

• VS Code: v1.105.0 or later.
• Java: Java 17+ or 21+ (recommended for modern Quarkus 3.x+ applications).
• Extension Dependency:
  • Quarkus Tools for Visual Studio Code (redhat.vscode-quarkus) by Red Hat (automatically installed as an extension dependency).
• Container Engine: Docker Desktop or Podman (required for Dev Services container detection and lifecycle management).

🚀 Getting Started

1. Open any Quarkus project in VS Code (single-module or multi-module Maven/Gradle).
2. Click on the Quarkus Studio icon in the Activity Bar.
3. In the Apps view:
   • Browse your project hierarchy and submodules.
   • Click the Start Dev Mode (▶) button next to any runnable application module.
   • Expand the Endpoints node to view all discovered REST endpoints. Click any endpoint to jump directly to its method in the source code, or click the browser icon to launch it.
   • Right-click the Endpoints node and choose Generate Postman collections to export a Postman Collection v2.1.0 file (AppName-<date>.postman_collection.json) directly into the project root's postman/ directory.
   • Click the inline Open Dev UI (🌐) icon on any running application row to open the dashboard (automatically detected on quarkus.http.port if configured).
4. In the Dev Services view:
   • View running containers provisioned by Quarkus or Docker/Podman.
   • Click Copy Connection String to use database/service credentials in external clients.
   • Click View Live Logs to inspect container stdout/stderr.
   • Click Open Web UI to access web management dashboards (e.g., Keycloak or Mailpit).
5. Open application.properties:
   • Start typing quarkus. or %dev.quarkus. to trigger intelligent autocompletion with build-time vs runtime tags.
   • Notice live Inlay Hints showing cloud memory and serverless invocation cost estimates.
   • Hover over properties to see detailed Native vs JVM cloud sizing metrics.
6. Generate Panache Entities & CRUD:
   • Right-click any package folder in Explorer and select Generate Panache Entity & CRUD.
   • Or right-click a .json file and select Generate Panache from JSON Payload.
   • Or right-click a .sql schema file and select Generate Panache from SQL / DDL Schema.
7. Live Continuous Testing & Feedback HUD:
   • Start Dev Mode for your Quarkus project.
   • Open any Java test file (*Test.java).
   • Observe live Quarkus Tests HUD in the Status Bar and green/red indicators in the editor gutter next to your test methods.
   • Hover over failing test gutter icons to view instant assertion failure messages and stack traces.
   • Edit any Java source or config file and press Save: failed tests are automatically re-run!
   • Switch or scaffold @TestProfile classes using the CodeLens link, sidebar action, or command palette.
8. Use Quarkus Studio Snippets (qs- / qs:):
   • In application.properties or application.yaml, type qs-http, qs-datasource-pg, qs-hibernate, qs-kafka, or qs-oidc to instantly scaffold datasources, security, messaging, and environment profiles.
   • In any .java file, type qs-gen to generate full Panache entities, repositories, REST CRUD resources, DTO records, or @QuarkusTest suites.
   • Type qs:log-info, qs:log-error, qs-transactional, qs-applicationscoped, qs-endpoint, qs-panache, or qs-val for instant Quarkus logging, annotations, endpoint methods, Panache queries, and Bean Validation constraints.

🛠 Extension Settings

Quarkus Studio provides the following configuration settings under quarkusStudio:

⌨️ Contributed Commands

Apps View Commands

Dev Services Commands

Config Assistant Commands

Panache Generator Commands

Continuous Testing Commands

Project Builder Commands