Contact Us About Sponsorship

Questions about Micronaut Foundation sponsorship?

Please complete this form, and we’ll follow up with you shortly.

A modern, JVM-based, full-stack framework for building modular, easily testable microservice and serverless applications

Reimagine startup time
and memory consumption

The Micronaut way

Your application startup time and memory consumption aren’t bound to the size of your codebase, resulting in a monumental leap in startup time, blazing fast throughput, and a minimal memory footprint.

The old way

When building applications with reflection-based IoC frameworks, the framework loads and caches reflection data for every bean in the application context.

Key
Features

Polyglot Framework

Compatible with Java, Groovy, and Kotlin, with Scala on the roadmap

Natively Cloud-Native

Built-in cloud support including discovery services, distributed tracing, and cloud runtimes

Fast Data-Access Config

Quick configuration of your favorite data-access layer and the APIs to write your own

Smooth Learning Curve

Realize benefits quickly by using familiar annotations in the way you are used to

Fast, Easy Unit Testing

Easily spin up servers and clients in your unit tests and run them instantaneously

Aspect-Oriented API

Provides a simple, compile-time, aspect-oriented programming API that does not use reflection

Seamless API Visibility

With support for OpenAPI and Swagger, your consumers will have everything they need to integrate with your services

AOT Compilation

Keeps your startup time and memory footprint low by doing the heavy lifting up-front

Who’s using Micronaut?

Micronaut success stories

See how Object Computing clients are achieving awesome results with the Micronaut framework.

Non-Blocking HTTP Server Based on Netty

import io.micronaut.http.annotation.*;

@Controller("/hello")
public class HelloController {

  @Get("/")
  public String index() {
    return "Hello World";
  }
}

Declarative, Reactive, Compile-Time HTTP Client

import io.micronaut.http.annotation.Get;
import io.micronaut.http.client.annotation.Client;
import io.reactivex.Single;

@Client("/hello")
public interface HelloClient {
  @Get("/")
  Single<String> hello();
}

Fast and Easy Testing

import io.micronaut.test.extensions.spock.annotation.MicronautTest
import spock.lang.Specification
import javax.inject.Inject

@MicronautTest
class HelloClientSpec extends Specification {
  @Inject
  HelloClient client

  void "test hello world response"() {
    expect:
    client.hello().blockingGet() == "Hello World"
  }
}

Natively Cloud Native

The Micronaut framework’s cloud support is built right in, including support for common discovery services, distributed tracing tools, and cloud runtimes.

Micronaut Apps start up in tens of milliseconds
with GraalVM

GraalVM is a new universal virtual machine from Oracle that supports a polyglot runtime environment and the ability to compile Java applications down to native machine code.

The Micronaut framework features a dependency injection and aspect-oriented programming runtime that uses no reflection. This makes it easier for Micronaut applications to run on GraalVM. Learn more

Works Hand-In-Hand with
Micronaut Data

Micronaut Data is a productivity-boosting open source technology that dramatically improves runtime and memory performance of data access repository logic for the microservice and serverless era.