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.

Status: in active development — release-candidate series toward GA. 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 orchestrationDeclarative cluster management
Java frameworksSlice model + resource provisioning
Application-scale streamingBuilt-in ordered, replayable streams
Distributed cachingConsensus-backed KV-Store + DHT
Service meshBuilt-in mTLS, routing, load balancing
Schema migration toolsBlueprint-bundled migrations
Connection poolersAsync driver with pipelining
Config & discovery servicesConsensus KV-Store
Certificate managementHKDF-derived certs, auto-rotation

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.

E

Ember

Embeddable runtime. Multiple logical nodes in one JVM. Standard debugger. The zero-risk entry point for legacy migration.

F

Forge

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

A

Aether

Cluster deployment. Same slices, different scale. Moving from Ember to Aether is primarily a configuration change, not a code change.

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. Start with Aether Ember in a single JVM alongside your existing application. Extract one hot path, deploy as a slice, route traffic.

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