A modern, JVM‑based framework for fast cloud applications

Build modular microservices and serverless applications with compile-time dependency injection, fast startup, low memory overhead, and GraalVM Native Image support.

Compile-time DINo runtime reflectionGraalVM native ready

View documentation Launch a project Browse guides

Your first Micronaut app

$ sdk install micronaut

$ mn create-app com.example.demo

Application created at ./demo

$ cd demo && ./gradlew run

Startup completed in 235ms. Server Running: http://localhost:8080

$ ./gradlew nativeRun

Startup completed in 15ms. Server Running: http://localhost:8080

Latest release: Micronaut 5.1.3 Download the CLI

Built around Micronaut's strongest differentiators

Compile-time APIs, native-image readiness, integrated testing, cloud support, and productive data access work together instead of competing for attention.

Compile-time dependency injection

The compiler resolves your dependency graph, so wiring mistakes fail the build.

Fast startup and low memory

Designed for lean services, serverless functions, and native images.

Cloud-native by default

Service discovery, tracing, configuration, and cloud runtime support.

Built-in testing support

Boot the real application in tests — and run the same suite as native tests.

HTTP server and client

Create controllers and declarative clients with familiar annotations.

Micronaut Data

Repository APIs with queries computed ahead of time.

OpenAPI visibility

Keep service contracts discoverable and documented.

Java, Kotlin, and Groovy

Use the JVM language that fits your team.

One application model, from endpoint to database

The same annotations declare an HTTP endpoint, the client that calls it, the repository behind it, and the JSON that crosses the wire — then boot the whole thing in a test.

Same annotations across server, client, and repository

Routes, queries, and JSON resolved by the compiler

Tests boot the real application context

A controller in a few annotations

import io.micronaut.http.annotation.*;

import java.util.Collections;
import java.util.Map;

@Controller("/hello")
class HelloController {

    @Get
    Map<String, String> index() {
        return Collections.singletonMap("message", "Hello World");
    }
}

import io.micronaut.http.annotation.Controller
import io.micronaut.http.annotation.Get

@Controller("/hello")
class HelloController {

    @Get
    fun index(): Map<String, String> {
        return mapOf("message" to "Hello World")
    }
}

import io.micronaut.http.annotation.Controller
import io.micronaut.http.annotation.Get

@Controller('/hello')
class HelloController {

    @Get
    Map<String, String> index() {
        [message: 'Hello World']
    }
}

Coming from a legacy JVM framework?

Legacy frameworks resolve the application model with reflection and classpath scanning while the application starts. Micronaut keeps the same familiar programming model but moves that work to the compiler — and the cost profile changes with it.

Resolved at runtime, on every startup

What a legacy reflection-based framework does each time your application boots.

Classpath scanning on every startup

Reflection metadata assembled while the app boots

Proxies generated on the fly at runtime

Startup cost and memory grow with each new bean

Wiring errors surface when the app starts in production

Resolved at build time, once

What Micronaut does instead, before your application ever ships.

Injection and AOP metadata generated by the compiler

No classpath scanning or reflection to start

Startup work stays flat as the codebase grows

Wiring errors fail the build, not the deployment

The same properties that make GraalVM Native Image practical

Explore migration guides

Cloud-native by default

A dedicated module for every major cloud and for Kubernetes, each wiring that platform’s own services into the same configuration, discovery, and deployment model.

Explore cloud support

Cloud Run, Cloud Functions

Oracle Functions, API Gateway

The rest of the platform

Native executables, data access, and the build plugins that produce them — maintained alongside the framework rather than bolted on beside it.

GraalVM native executables

Compile applications with GraalVM into native executables that start in milliseconds and hold a fraction of the memory of a JVM deployment.

Same app	JVM	Native
Startup	235 ms	15 ms
Memory	356 MB	42 MB

Reachability metadata generated with your beans

Container images and AWS Lambda custom runtimes

The same suite runs as native tests

Learn about GraalVM

Micronaut Data, across your datasources

Repository interfaces the compiler writes the queries for — over SQL, reactive, and document stores alike.

Access styles

Jakarta DataJDBCJPA / HibernateR2DBCHibernate Reactive

Datasources

PostgreSQLMySQLMariaDBOracleSQL ServerSQLiteH2ANSI SQLMongoDBAzure Cosmos DB

Queries written by the compiler, not assembled at runtime

Repositories and entity mappings validated at compile time

No runtime model scanning, and no reflection overhead

View Micronaut Data docs

Build plugins for Gradle and Maven

One plugin per build tool folds native images, containers, and test infrastructure into the build command you already run.

Gradle Maven

Native builds. nativeCompile, nativeRun, and nativeTest — or mn:native-image and mn:graalvm-resources.

Container images. dockerBuild and dockerBuildNative, with CRaC checkpoints and a push goal.

Test Resources. Databases and brokers started for dev and test runs, then torn down.

AOT optimization. Micronaut AOT analysis moves more work off startup and into the build.

Config validation. Configuration checked before packaging, per environment.

Who’s using the Micronaut Framework?

See how Micronaut users are achieving results with the Micronaut framework across serverless APIs, migrations, workflow platforms, and cloud services.

View all success stories