This Is What Happens When You Push Quarkus Way Too Far

A Java engineer’s tour through Minecraft observability, AI hallucinations, native CLIs, and other “bad ideas” that reveal how Quarkus really works.

At JChampions Conference, Holly Cummins, Senior Principal Software Engineer at IBM, gave a talk with a title that already tells you what kind of session this was: Six and a Half Ridiculous Things to Do with Quarkus.

This was not a “hello world” talk. And it was not a checklist of best practices. It was a reminder of something we sometimes forget when we talk about frameworks only in terms of benchmarks and cloud bills:

Quarkus is also a playground.

What follows is not a transcript, but a guided walkthrough of the ideas behind the demos and what they tell us about Quarkus as a platform. And yes, some of them are ridiculous on purpose.

Note: You can find Holly’s post with slides on her blog.

Translating Your API into Gen Alpha Slang

The first demo looks innocent. A basic Quarkus REST endpoint returns "Hello World". (Source code)

Then Holly adds a ServerResponseFilter.

Every response leaving the application is intercepted and passed through a translation layer. The result is no longer normal English. It is “Gen Alpha” slang. Things like “chicken jockey” appear where you least expect them.

Nothing in the application logic changes. No controller code. No service code. Just a response filter.

This is funny, but the technical point is serious. Quarkus makes server-side response interception trivial. Once you have that hook, you can do anything: content transformation, redaction, localization, watermarking, or policy enforcement.

The important takeaway is not the slang. It is how easy it is to intercept output at the framework level and still keep your application code clean.

Editing Source Code from the Dev UI

Most of us think of the Quarkus Dev UI as a dashboard. You look at config, health, metrics, and maybe logs. (Source.)

Holly pushes this idea further.

She shows a “joke” extension that adds buttons to the Dev UI. These buttons do not just display information. They actively modify the source code on disk. One click reverses the code. Another mutates it in creative ways.

This works because the Dev UI now supports assistants. These assistants combine runtime knowledge with tooling that can write or modify code.

Yes, this demo is playful. But the underlying idea is powerful. The Dev UI is no longer just observability. It is becoming an interaction surface between the running system and the developer.

That is exactly where things like AI assistants, refactoring helpers, or guided debugging tools belong.

Rockstar on the JVM

Next up: a compiler. (Source/Quarkus Extension)

Not a Java compiler. A compiler for Rockstar. That is a programming language where the source code looks like 1980s rock lyrics.

Holly implements a Rockstar compiler using Antlr and runs it on the JVM with Quarkus. Then she demonstrates live reload. She edits the lyrics in the IDE, saves the file, and the running application immediately updates.

FizzBuzz. Written as a power ballad.

This sounds absurd. But again, there is a serious lesson here. Quarkus is extremely friendly to alternative languages and unconventional execution models. If you want to experiment with DSLs, scripting languages, or embedded runtimes, Quarkus does not fight you.

It gets out of the way.

Making LLM Hallucinations Worse on Purpose

This part gets uncomfortable, and that is the point. (Source code)

Using LangChain4j with Quarkus, Holly builds a chatbot that fails at very simple tasks. For example, counting the number of r characters in “strawberry”.

Then she adds a “hallucination guard”.

But instead of using the guard to improve correctness, she tunes it to prefer ridiculous answers. The more confident and wrong the answer is, the more likely it gets accepted.

This demo lands a hard truth. Context and memory are not free. More context does not automatically mean better answers. Past a certain point, you pay more and get worse results.

If you build AI systems with Quarkus, or any framework, this is the warning sign to remember. Guardrails can help. But they can also amplify failure if you use them blindly.

Minecraft as an Observability Tool

Now for the most visual demo. (Source/Quarkus Extension)

Instead of Grafana dashboards, Holly uses Minecraft as an observability frontend. A Minecraft server is started via Quarkus Dev Services. Application events are mapped to in-game effects.

Add a to-do item? A cow appears.
Delete one? Another animal.
Trigger an error? Explosion.

It is ridiculous. And it is brilliant.

Observability is about making invisible things visible. Minecraft turns abstract system events into something you can see and feel. It also shows how easy it is to spin up complex external systems in development using Dev Services.

You probably will not run Minecraft in production. But the idea sticks: observability does not have to look like a chart.

Instant Meme Generation with Quarkus Native

The sixth demo goes back to performance. (Source code)

Using Quarkus, Picocli, and GraalVM, Holly builds a CLI tool that generates memes. The key point is startup time.

The native binary starts instantly. No warm-up. No JVM delay. You type the command and the meme appears.

This is exactly where Quarkus native mode shines. CLIs, short-lived tools, and developer utilities benefit a lot from instant startup. You do need to be aware of limitations, like graphics support on some operating systems, but the trade-off is often worth it.

The Lemon Benchmark

Finally, the half point. (Source)

Holly introduces the “grapefruit benchmark”. Or lemon benchmark. The idea is simple. Measure energy consumption and translate it into something tangible.

According to her calculation, running a Spring-based application for an hour would require the energy equivalent of around 40,000 lemons. A Quarkus application would need about 17,000 lemons.

This is playful math, but the message is clear. Lower resource usage is not just about speed. It is about cost. And it is about environmental impact.

Efficiency matters.

What This Talk Really Shows

This talk is not about copying these demos into your production system.

It shows something more important.

Quarkus is not just a “fast Java framework”. It is a platform that encourages experimentation. It gives you hooks. It lets you bend it. Sometimes even break it. And in doing so, you learn what is actually possible.

If you only ever use a framework in the most conventional way, you never see its edges. Holly’s talk walks straight to those edges and leans over.

That is where the interesting stuff lives.