How to Use Quarkus Dev Mode and Continuous Testing
Use Quarkus dev mode for live reload, the keyboard commands and continuous testing that reruns tests when you save, and know what dev mode cannot reload.

Most Java web frameworks make you wait: change a line, rebuild, restart the server, reload the page, a loop of ten to sixty seconds repeated hundreds of times a day. Quarkus dev mode collapses it. You start one process, edit a source file, hit refresh and the change is there, because the framework recompiles and reloads on the next request without restarting the JVM. On top of that sits continuous testing, which re-runs the tests affected by each change in the background. Used together they make the edit-and-verify loop feel closer to a scripting language than to enterprise Java. This post covers how to start dev mode, how live reload works, the keyboard commands, continuous testing, the Dev UI and the limits of what dev mode can reload. Examples use Quarkus 3 and JDK 25. The build-time design that makes this possible is explained in Quarkus build time processing.
Start it
From a Quarkus project, one command starts the application in dev mode:
./mvnw quarkus:devor with the Quarkus CLI, quarkus dev; with Gradle, ./gradlew quarkusDev. A new project to try it on comes from a single command, as in a Quarkus tutorial building a first REST API:
quarkus create app dev.javahacks:shop --extension='rest,hibernate-orm-panache,jdbc-postgresql'
cd shop
quarkus dev__ ____ __ _____ ___ __ ____ ______
--/ __ \/ / / / _ | / _ \/ //_/ / / / __/
-/ /_/ / /_/ / __ |/ , _/ ,< / /_/ /\ \
--\___\_\____/_/ |_/_/|_/_/|_|\____/___/
INFO [io.quarkus] shop 1.0.0-SNAPSHOT on JVM (powered by Quarkus 3.x) started in 1.842s. Listening on: http://localhost:8080
INFO [io.quarkus] Profile dev activated. Live Coding activated.
INFO [io.quarkus] Installed features: [cdi, hibernate-orm, jdbc-postgresql, rest, smallrye-context-propagation]
--
Tests paused
Press [e] to edit command line args (currently ''), [r] to resume testing, [o] Toggle test output, [:] for the terminal, [h] for more options>Two lines matter. Live Coding activated means source changes will be picked up. Tests paused is continuous testing, waiting for you to turn it on. If you configured a database extension and have Docker running, Dev Services starts a PostgreSQL container for you with no connection settings, which makes the application fully runnable from nothing; those are covered in Quarkus Dev Services for databases and brokers. A first run may take longer while dependencies download and the container image is pulled.
Live reload
Leave the process running, edit a resource class and save:
@Path("/hello")
public class GreetingResource {
@GET
@Produces(MediaType.TEXT_PLAIN)
public String hello() {
return "Hello from Quarkus"; // change this string and save
}
}curl -s localhost:8080/helloHello from QuarkusChange the string to Hello again, save, and call it again:
curl -s localhost:8080/helloHello againThe terminal where dev mode runs prints what happened:
INFO [io.qua.dev] Changed source files detected, recompiling [src/main/java/dev/javahacks/shop/GreetingResource.java]
INFO [io.quarkus] shop stopped in 0.021s
INFO [io.quarkus] shop started in 0.348s. Listening on: http://localhost:8080The reload is triggered by the request. Quarkus watches your source directories, and when the next HTTP request arrives it checks whether anything changed, recompiles only the changed classes, and restarts the application context in-process, in a few hundred milliseconds, using a fresh class loader for your code while the JVM and the framework's class loader stay up. It does the same for resources (application.properties, templates, static files), for pom.xml changes (it re-resolves dependencies and restarts) and for added or removed classes. A compile error does not crash the process; it shows an error page in the browser with the failing line and waits for you to fix it, and the next save recovers. The restart is fast because of how Quarkus works: most of the framework's initialization happens at build time, and what remains is small, as explained in the build-time post above.
Because the build-time work reruns on each reload, dev mode is where a configuration property that is "fixed at build time" takes effect without a manual rebuild. In production you rebuild; in dev mode the reload does it for you. Keep in mind that this hides the difference, so test changes to such properties with a real build before shipping them.
Keyboard commands
The terminal is interactive. Single keys control the session, and h prints the full list. The ones used constantly:
| Key | Action |
|---|---|
r | Resume or pause continuous testing |
o | Toggle test output |
f | Re-run only the failed tests |
w | Open the application in the browser |
d | Open the Dev UI in the browser |
s | Force a restart (reload without a source change) |
e | Edit the command line arguments |
b | Open the application's base URL |
i | Toggle instrumentation based reload |
l | Set the log level of a logger |
h | Show help for all commands |
q | Quit |
s is the one for when the application is in a bad state and you want a clean context without restarting the whole process. l changes a logger's level on the fly, which is useful for turning one package to DEBUG without touching configuration. : opens a small terminal for commands such as adding extensions. The exact list can vary with the Quarkus version, so use h.
Continuous testing
Press r and Quarkus runs your test suite, then watches for changes and re-runs the tests affected by each one. Affected is computed from which classes each test touches, so editing GreetingResource re-runs the tests that exercise it and skips the rest. The feedback appears in the same terminal:
--
Tests all passed
Press [e] to edit command line args, [r] to re-run, [o] Toggle test output, [:] for the terminal, [h] for more options>
Test run finished: 12 tests passed in 2.4sBreak something on purpose and save:
FAILED GreetingResourceTest.testHelloEndpoint
java.lang.AssertionError: 1 expectation failed.
Response body doesn't match expectation.
Expected: is "Hello from Quarkus"
Actual: Hello again
--
Tests failedYou get the failing test and the assertion within seconds of saving, without leaving the editor or running a separate command. The test is a normal @QuarkusTest:
@QuarkusTest
class GreetingResourceTest {
@Test
void testHelloEndpoint() {
given().when().get("/hello")
.then().statusCode(200).body(is("Hello from Quarkus"));
}
}Tests run against the same running application (a test instance of it), so there is no per-run startup cost beyond the first, and the same Dev Services containers are reused. Start in the mode you want with quarkus dev -Dquarkus.test.continuous-testing=enabled, or set it in application.properties for the dev profile. If the suite gets slow, tag the slow tests and let continuous testing run a subset by tag (quarkus.test.include-tags). The continuous testing guide lists the options. Compared with JVM suites that take ten seconds to boot, the difference in the loop is large, and it changes how often people run tests at all.
The Dev UI
Press d, or open http://localhost:8080/q/dev-ui. The Dev UI is a web console served by the running application, with a page for each extension. For a REST application with a database, the useful screens are:
- Endpoints: every route the application exposes, with a button to call it.
- Configuration: every property, its current value and where it came from, editable live; you can see which properties are build-time and which are runtime.
- ArC (CDI): the beans, their scopes and dependencies, and the interceptors, which shows what the container actually built.
- Hibernate ORM: the persistence units, the entities and a query console to run HQL against the dev database.
- Dev Services: the containers started, with their connection details and logs.
- Continuous testing: the same test feedback in a graphical form.
- Swagger UI and health: when those extensions are present.
It is the fastest way to answer "what did Quarkus register" without reading logs. It is only available in dev mode and is not packaged into the production build.
What dev mode cannot reload
Live reload is broad and not total. These need a restart of the dev mode process (q, then start again):
- Changes to classes outside your project that were not part of the reload, such as a dependency jar built separately; dev mode reloads your module and the modules of a multi-module build that are in the workspace, but not artifacts from a repository.
- JVM flags and the JDK: options passed to the JVM itself.
- Some build-time customizations from extension build steps or the Maven compiler configuration changes that alter annotation processing.
- Static state that leaks across reloads: a static field holding a thread, a connection or a cache created outside the framework's lifecycle survives or breaks across a reload. Keep resources in CDI beans so the container manages them.
- Native image behavior: dev mode runs on the JVM, so reflection and resource problems that appear in a native build do not appear here; run the native tests in CI.
- Differences from production: dev mode uses the
devprofile, Dev Services instead of your real database, and lenient defaults. A feature that works here still needs a production-like test.
If a change seems ignored, press s to force a restart, check for a compile error on the error page and look at the log for the line that says what was detected.
Where this does not apply
For a project that is mostly Spring, the closest equivalent is Spring Boot DevTools with a restart on classpath change, which restarts the context and is slower than Quarkus's reload; the comparison for Spring developers is in Quarkus for Spring developers. For a library with no HTTP endpoints, dev mode still helps with continuous testing, but the live reload on request has nothing to trigger it. And for debugging, dev mode opens a debug port (5005 by default), so attach your IDE to it instead of restarting the process in debug. The Maven side of the command is documented in the Maven tooling guide.


