I've been heads-down for the past few months building something that's been gnawing at me for a while. You know that feeling when you're writing async PHP and you're juggling promises, dealing with memory leaks in long-running processes, and fighting with static properties that just won't let go? It's an uphill battle.

Well, I started building a solution. And funny enough, this morning I saw Symfony announce some similar thoughts at their conference. Great minds, right? But while they're taking their approach, I've been working on something a bit... different.

The Problem with PHP's Async Story

Here's the thing - PHP has amazing async runtimes. ReactPHP, Amp, Swoole... they're all fantastic. But using them feels like you're fighting the language sometimes. You've got:

• Interfaces scattered across different implementations
• Docblock parsing to figure out what's actually happening (recent MCP server approaches)
• Static properties lurking everywhere, ready to blow up your memory
• Superglobals that make true isolation impossible

I kept thinking: what if we could build something that felt as natural as writing synchronous PHP, but gave us all the async power we need?

Enter Aether

It's what I've been building. Aether is a complete rethinking of how PHP applications should work in 2025. And yes, it's built on PHP 8.4's cutting-edge features, unapologetically.

Here's a taste of what I'm talking about. Not sure if you've tried building an MCP server with the existing tooling that's out there to date? In Aether, it's an entirely different approach (note: the API is still being developed and subject to change):

#[MCPServer(name: "devops-assistant")]
class DevOpsServer {
    #[Tool(
        name: "docker_ps",
        description: "List running containers on a server"
    )]
    public function listContainers(
        #[Param(description: "Hostname or IP")] string $host
    ): Promise {
        return $this
            ->ssh($host)
            ->exec('docker ps --format json')
            ->then(fn($containers) => array_map(
                fn($c) => json_decode($c, true), 
                explode("\n", $containers)
            ));
    }
    
    #[Tool(name: "server_status")]
    public function serverStatus(string $host): ServerStatus {
        // All fully typed, all async, all memory-safe
        return ServerStatus::check($host);
    }
}

Type safety is a front and center, and you'll just need to ensure your return type implements the McpResponse interface. No docblocks for typing. No string-based container resolution. No memory leaks from static registries. Just clean, async PHP.

The Secret Sauce

The magic happens in how Aether handles the hard stuff:

1. Zero Static Properties: "singleton"s will be hidden behind transient proxies. Your database connection? It's managed by the framework, but you'll never see a static property.

2. True Async-First: Not async-sometimes or async-when-you-remember. Everything is built from the ground up for long-running processes.

3. Manifest-Based Configuration: Remember those 500-line configuration files? Gone. Everything is code, everything is typed:

HttpManifest::define(function ($http) {
    $http->listen('0.0.0.0', 8080)
         ->middleware([RateLimiter::class, Cors::class])
         ->when($this->isProduction(), fn($http) => 
             $http->compress()->cache()
         );
});

4. PHP 8.4 Property Hooks: Reactive programming built into the language itself. No more manual observer patterns.

The Bootstrapping Journey

What's wild is watching this thing bootstrap itself. I started with the core container (using WeakMaps for proper memory management), then built the runtime abstraction, then the scoping system... Each piece building on the last, each one making the next easier to implement.

The framework is literally building itself at this point. The manifest system I wrote last month is now being used to configure the routing system I'm building this month. It's been recursive improvement at its finest.

What's Next?

I'm not ready to release this yet - there's still work to do on the developer experience tools and documentation. But I'm getting there.

The goal isn't to replace Laravel or Symfony. They're fantastic for what they do. The goal is to provide something for when you need:

• True long-running process support
• Memory-safe async operations
• AI-native application development
• 100% type safety without sacrificing developer experience

If you're tired of fighting with PHP to build modern async applications, stay tuned. Something better is coming 🤞.

Want to be notified when Aether launches? Drop me a line. I'm keeping a list of folks who want early access to break things and tell me what sucks. mail@jhavens.tech