Running Java Should Be As Easy As Writing It

Aether is the unified application runtime for Java. It aims to replace much of your infrastructure stack. Write business logic as typed interfaces, and the runtime handles the machinery between your code and deployment.

Get Started How It Works

Status: in active development — release-candidate series toward GA; current candidate 1.0.0-rc3 (2026-09-02). Not yet production-ready.

@Slice
public interface OrderService {
    Promise<OrderResult> placeOrder(PlaceOrderRequest request);

    static OrderService orderService(InventoryService inventory,
                                     PricingEngine pricing) {
        return request -> inventory.check(request.items())
                .flatMap(pricing::calculate)
                .map(OrderResult::placed);
    }
}

Let Java Be Java

Write an interface annotated with @Slice. Aether is built to handle distribution, scaling, resilience, observability, and zero-downtime deployments.

No HTTP clients. No service discovery. No retry logic. No circuit breakers. No serialization code. A method call is the only visible contract.

The Infrastructure Tax

Every Java service you deploy carries a hidden cost.

Operational Burden

Container orchestration, service mesh, config management, secret rotation, certificate management, schema migrations, connection pooling, load balancing. A platform team becomes mandatory just to keep Java services running.

The Coupling Trap

Every microservice bundles web servers, serialization, DI containers, service discovery, metrics, and retry logic. Infrastructure and business logic compile together, deploy together, break together. A security patch means rebuilding every service.

Configuration Explosion

A typical Java microservice exposes hundreds of configuration surfaces. Multiply by the number of services, multiply by the number of environments. Managing this becomes a full-time job.

What Aether Handles

One runtime. One configuration. One deployment command.

You currently manage...	Aether handles it
Container orchestration	Declarative cluster management
Java frameworks	Slice model + resource provisioning
Application-scale streaming	Built-in ordered, replayable streams
Distributed caching	Consensus-backed KV-Store + DHT
Service mesh	Built-in mTLS, routing, load balancing
Schema migration tools	Blueprint-bundled migrations
Connection poolers	Async driver with pipelining
Config & discovery services	Consensus KV-Store
Certificate management	HKDF-derived certs, auto-rotation

See the feature catalog

Why Now

Platform Engineering Fatigue

Teams are pushing back on operational complexity. The question shifted from "how do we run more tools?" to "how do we run fewer?"

Streaming Uncertainty

Major acquisitions and team cuts in the streaming space are forcing enterprises to re-evaluate their event infrastructure.

Cloud Cost Pressure

Organizations are asking: "do we really need all these managed services?" Self-managed deployment that's just as easy changes the math.

From Laptop to Cluster

Three environments, one codebase.

Ember

Development runtime. Multiple logical nodes in one JVM. Standard debugger. For the dev loop and tests.

Forge

5-node cluster simulator on your laptop. Real consensus, real routing, chaos injection. Web dashboard with live metrics.

Aether

Cluster deployment. The slice sources stay the same. What changes is deployment (blueprints), resource configuration, and operations.

See It In Action

Cluster setup, slice deployment, load testing — end to end.

Aether Topology Dashboard — live data-flow graph showing endpoints, slices, resources, and pub-sub topics

Topology Dashboard — compile-time data-flow graph with swim-lane layout, pub-sub routing, and search filtering.

Start Small, Prove Value

You don't have to go all-in. Extract one hot path, deploy it as a slice, route traffic to it, and repeat.

First slice running in Forge in under an hour. Built with JBCT (Java Backend Coding Technology) — deterministic patterns optimized for human-AI collaboration.

Get Started Ask a Question