Which Frameworks and Cloud Platforms Support GraalVM?

GraalVM lists first-class support from four Java frameworks — Spring Boot, Micronaut, Helidon, and Quarkus — and integration from SDKs of four cloud platforms: AWS, Microsoft Azure, GCP, and Oracle Cloud Infrastructure. If your stack is built on one of these, you can generally expect a supported path to Native Image; if you use a different framework or cloud provider, you'll need to verify compatibility yourself before committing.

Framework support

GraalVM's site states that "popular frameworks such as Spring Boot, Micronaut, Helidon, and Quarkus provide first-class support for GraalVM." In practice, "first-class support" means the framework project itself maintains the integration — build plugins, configuration for ahead-of-time compilation, and handling of reflection and resource metadata that Native Image needs.

The practical benefit: you're not hand-writing the reflection configuration that Native Image requires. The framework's build tooling generates it. That matters because Native Image compiles ahead of time and includes only the classes, methods, and fields your application actually reaches — which is also why GraalVM describes native executables as having a reduced attack surface.

What "first-class" does not guarantee

First-class support is a statement about the framework, not about every library you add on top. A Spring Boot app using a mainstream starter is a different case from one using an obscure library that relies on dynamic class loading. Before you commit, check whether your specific dependencies ship GraalVM metadata. If they don't, expect to supply configuration or replace the library.

Cloud platform integration

GraalVM states that SDKs from AWS, Microsoft Azure, GCP, and Oracle Cloud Infrastructure "integrate and support GraalVM." This is about the vendor SDKs your application calls, not about whether you can deploy a native executable to a given cloud — a native binary is a standalone executable, so deployment is generally a packaging question rather than a platform-permission question.

If your application talks to one of these clouds through the official SDK, the integration is documented as supported. If you use a third-party client or a community SDK, that claim doesn't extend to it.

Why this matters for Native Image specifically

The reason framework and SDK support is the deciding factor — rather than a nice-to-have — is the nature of ahead-of-time compilation. GraalVM's own framing of Native Image centers on four properties:

• Low resource usage — native executables use only a fraction of the memory and CPU a JVM requires.
• Fast startup — executables start instantly with no warmup.
• Compact packaging — small binaries with linking options suited to minimal container images.
• Improved security — only reachable classes, methods, and fields are included.

Every one of those benefits depends on the compiler being able to see your code paths at build time. Frameworks and SDKs that pre-declare their dynamic behavior make that possible; ones that don't will either fail the build or fail at runtime. So the support list is effectively a list of stacks where the ahead-of-time model works without you doing the metadata work.

How to decide for your project

Use this as a checklist rather than a verdict:

1. Framework — Is it Spring Boot, Micronaut, Helidon, or Quarkus? If yes, you have a supported starting point. If no, check that framework's own documentation for GraalVM guidance before proceeding.
2. Cloud SDK — Do you call AWS, Azure, GCP, or OCI through the official SDK? If yes, that layer is covered. Third-party clients need separate verification.
3. Dependencies — Do your non-framework libraries publish GraalVM metadata? This is the most common place a supported stack still hits friction.
4. Version — GraalVM's site references GraalVM 25.4 as the current release, with new compiler optimizations, smaller Native Image binaries, and advanced Truffle and WebAssembly capabilities. Confirm your framework version supports the GraalVM release you plan to use.

If steps 1 and 2 both pass and step 3 is clean, the supported path is straightforward. If step 3 is unclear, treat it as the gating item — it determines whether you get the startup and memory benefits or spend the effort on configuration instead.