A high-performance coroutine framework powered by an event-driven engine. Handle thousands of concurrent connections with a fraction of the resources traditional PHP setups demand.
A coroutine-based CLI framework built for speed and flexibility. It ships with battle-tested components for microservices, messaging, observability, and more — all production-ready out of the box.
Every request runs in its own lightweight coroutine. I/O waits no longer block your entire process — dozens of database queries execute in the time a single blocking call would take.
A best-in-class container with automatic resolution, constructor injection, and interface binding. Components are pluggable and testable by design.
Cross-cutting concerns like logging, caching, and authentication are woven into your logic via interceptors — keeping business code clean and focused.
Built-in gRPC, JSON-RPC, and service discovery integration. Compose independent services that scale horizontally without touching a single line of framework code.
Every core component strictly follows PHP-FIG standards. Mix and match with other PSR-compatible libraries without lock-in or compatibility headaches.
Coroutine-native clients for MySQL, Redis, RabbitMQ, Elasticsearch, HTTP, and more. No need to hunt for async wrappers — they're all first-class citizens.
A comprehensive testing suite with coroutine-aware assertions, mocking utilities, and test isolation. Write tests that run as fast as your production code.
A suite of command-line utilities for scaffolding projects, running migrations, seeding data, and managing workers — all designed to feel native in your terminal.
A C-based extension that transforms PHP from a synchronous scripting language into a high-performance, asynchronous runtime — without leaving the PHP ecosystem.
User-space threads with near-zero switching cost. Write synchronous-looking code that behaves asynchronously under the hood.
A high-performance reactor powered by epoll/kqueue. Handles tens of thousands of connections in a single process.
The application stays resident between requests. Config, connections, and cached data survive — no cold starts.
An HTTP, WebSocket, and TCP server baked into the extension. Skip Nginx and PHP-FPM entirely for your API layer.
If you know PHP, you already know most of it. The framework feels natural — controllers, middleware, dependency injection — but runs on an engine that processes requests 10 to 20 times faster than traditional PHP-FPM stacks.
// Coroutine-native database + HTTP in one request co(function () { $user = UserModel::find($id); // Runs concurrently — not sequentially $profile = httpGet("/api/profile/{id}"); $activity = cacheGet("activity:{id}"); return [$user, $profile, $activity]; });
A quick look at what changes when you move from a process-per-request model to a persistent, coroutine-driven runtime.
| Capability | PHP-FPM (Traditional) | Coroutine Runtime |
|---|---|---|
| Request Model | New process per request | Persistent, event-driven |
| Concurrent I/O | ✗ Blocking by default | ✓ Non-blocking coroutines |
| Memory Between Requests | Discarded after each cycle | Persisted in worker memory |
| WebSocket Support | Requires external tooling | ✓ Built-in server |
| Database Connections | Opened and closed per request | Coroutine-native connection pools |
| Throughput (req/s) | ~300–500 | ~5,000–7,000+ |
Join thousands of developers who have already made the jump to coroutine-based PHP. Start building high-concurrency applications today.
Get Started