Download the PHP package yangusik/laravel-spawn without Composer

Laravel adapter for PHP TrueAsync — a PHP fork with a native coroutine scheduler and async I/O. Think Laravel Octane, but instead of Swoole or RoadRunner the runtime is TrueAsync.

One worker. Many requests. Zero threads. Each HTTP request runs in its own coroutine with isolated state — no shared memory, no leaks between requests.

How it works

• Each request = a separate coroutine with its own Scope
• Request-scoped services (auth, session, cookie) are isolated via coroutine_context() and request_context() (if use True Async Server)
• PDO Pool transparently gives each coroutine its own database connection and returns it when the coroutine ends
• No container cloning — isolation is handled at the coroutine level, not by copying the entire app

Requirements

• PHP TrueAsync fork 8.6+
• Laravel 12+
• For FrankenPHP mode: trueasync/php-true-async:latest-frankenphp Docker image

Installation

Via git repository:

Via local path:

Then run composer update.

The service provider is auto-discovered by Laravel.

Replace the Application class in bootstrap/app.php:

This is required for per-coroutine isolation of auth, session, and request. Without it the service adapters register correctly but state isolation does not work.

Publish the config:

Servers

True Async Server

Production-ready adapter using True Async Server in async worker mode.

Check config/async.php!

Dev server

Simple TCP socket server for local development. Analogous to php artisan serve.

FrankenPHP

Production-ready adapter using FrankenPHP in async worker mode. Requires the trueasync/php-true-async:latest-frankenphp Docker image.

Docker quick start

TrueAsyncServer (better)

Dev server

FrankenPHP

Configuration

config/async.php:

If you use TrueAsyncServer, pls read docs: Configuration

Benchmarks (Obsolete use TrueAsyncServer)

Check results in HttpArena

Load: 840 req/s /hello + 360 req/s /test = 1 200 req/s total · constant-arrival-rate · 30s · 12 workers each · WSL2 (Linux 6.6 on Windows)

Why TrueAsync wins on DB-bound load

Swoole keeps the app in memory (avoids bootstrap cost) but PDO is still synchronous — a worker blocked on a DB call cannot accept another request. TrueAsync yields the coroutine on every DB call, so one worker handles hundreds of concurrent DB-bound requests without blocking.

Notes

• Each adapter has its own PostgreSQL instance on a separate port to avoid interference
• APP_DEBUG=false in all setups for fair comparison
• OPcache enabled in PHP-FPM
• max_connections=500 in all PostgreSQL instances
• Absolute numbers will be higher on bare metal (benchmarks run on WSL2)

Full benchmark: ta_benchmark

Raw PHP — TrueAsync vs Swoole (no framework, no I/O)

On pure CPU-bound workloads both servers cap at the same throughput (~10k req/s). With optimal Swoole config (ZTS, 16 reactor threads) Swoole is ~1.6x faster on P95 latency due to FrankenPHP's Go↔PHP boundary overhead (futex synchronization). On I/O-bound workloads this overhead is negligible.

Sessions

Database sessions (built-in fix)

The package automatically replaces Laravel's DatabaseSessionHandler with an async-safe version that uses upsert instead of INSERT + catch + UPDATE.

In a standard async server the HTTP response is sent before kernel->terminate() writes the session. If the client immediately sends the next request with the same cookie, two coroutines can race to INSERT the same session ID — causing duplicate-key warnings in the stock handler. The upsert is atomic, so this race is impossible regardless of concurrency.

No configuration needed. Works transparently when SESSION_DRIVER=database.

Redis sessions (recommended for production)

For high-concurrency workloads Redis sessions have lower overhead than database sessions and avoid any persistence race entirely:

License

MIT