PHPackages                             modelslab/octane-coroutine - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [Queues & Workers](/categories/queues)
4. /
5. modelslab/octane-coroutine

ActiveLibrary[Queues & Workers](/categories/queues)

modelslab/octane-coroutine
==========================

Laravel Octane with Swoole Coroutine support for massive concurrency and non-blocking I/O

v0.8.18(2w ago)51.8k1[1 issues](https://github.com/ModelsLab/octane-coroutine/issues)[1 PRs](https://github.com/ModelsLab/octane-coroutine/pulls)MITPHPPHP ^8.1.0CI passing

Since Nov 22Pushed 1w agoCompare

[ Source](https://github.com/ModelsLab/octane-coroutine)[ Packagist](https://packagist.org/packages/modelslab/octane-coroutine)[ RSS](/packages/modelslab-octane-coroutine/feed)WikiDiscussions main Synced 1w ago

READMEChangelog (10)Dependencies (147)Versions (39)Used By (0)

Laravel Octane with Swoole Coroutine Support
============================================

[](#laravel-octane-with-swoole-coroutine-support)

⚡ **High-performance Laravel** with true coroutine support for massive concurrency

[![Packagist Version](https://camo.githubusercontent.com/4ba0f19d170ef3061ac2d3861106b1d3d238f969850bd4e4a69cf19bcf81bb96/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f762f6d6f64656c736c61622f6f6374616e652d636f726f7574696e652e737667)](https://packagist.org/packages/modelslab/octane-coroutine)[![Packagist Downloads](https://camo.githubusercontent.com/2f40b73b0c2ae57245cada55835805c55ef798a94e69201e8be4447492f1ded4/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f64742f6d6f64656c736c61622f6f6374616e652d636f726f7574696e652e737667)](https://packagist.org/packages/modelslab/octane-coroutine)[![License](https://camo.githubusercontent.com/7013272bd27ece47364536a221edb554cd69683b68a46fc0ee96881174c4214c/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f6c6963656e73652d4d49542d626c75652e737667)](LICENSE.md)[![PHP Version](https://camo.githubusercontent.com/092d545f529c0bc11f393035f40f9cced2c9db2a0d148532f4fc2aa5409dc992/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f7068702d253545382e312d3737374242342e737667)](https://php.net)[![Laravel](https://camo.githubusercontent.com/187891f01cbc1f1bbd6dc4bc13d173b24055f11cd294ca9f83c82d279e74fade/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f6c61726176656c2d2535453130253743253545313125374325354531322d4646324432302e737667)](https://laravel.com)[![Swoole](https://camo.githubusercontent.com/4c20f464980bb939db9d03e8e07eea3bca3d6e6decca3a649fdcb6754f586150/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f73776f6f6c652d72657175697265642d3030414444382e737667)](https://www.swoole.co.uk)

> Requires the latest Swoole with coroutine hooks enabled. Older versions are not supported.

🚀 What is this?
---------------

[](#-what-is-this)

This is an **enhanced fork** of Laravel Octane that adds **true Swoole coroutine support**, enabling your Laravel application to handle thousands of concurrent requests efficiently through non-blocking I/O.

### Performance Highlights

[](#performance-highlights)

- **360× faster** than standard Octane (2,773 req/s vs 7.71 req/s baseline)
- **87× per-worker efficiency** through coroutines
- Handle **20,000+ concurrent connections** on a single server
- **Production-tested** under extreme load

⚡ The Problem with Standard Octane
----------------------------------

[](#-the-problem-with-standard-octane)

Standard Octane uses a "One Worker = One Request" model. When a request performs blocking I/O (database queries, API calls, file operations), the entire worker is blocked:

```
8 workers × 1 request per worker = 8 concurrent requests max

```

With 1-second blocking operations, this means only **~8 requests/second** throughput.

🎯 The Solution: Runtime Coroutine Hooks
---------------------------------------

[](#-the-solution-runtime-coroutine-hooks)

This fork enables **Swoole's coroutine runtime hooks** (`SWOOLE_HOOK_ALL`), which automatically converts PHP's blocking functions into non-blocking, coroutine-safe versions:

```
32 workers × ~87 concurrent requests per worker = 2,784+ concurrent requests

```

With the same 1-second blocking operations, this achieves **2,773+ requests/second** — a **360× improvement**!

### What Gets Hooked?

[](#what-gets-hooked)

- ✅ `sleep()` → Non-blocking coroutine sleep
- ✅ `file_get_contents()` → Non-blocking file I/O
- ✅ `curl_exec()` → Non-blocking HTTP requests
- ✅ MySQL/PostgreSQL → Non-blocking database queries
- ✅ Redis → Non-blocking cache operations
- ✅ File operations → Non-blocking reads/writes

📦 Installation
--------------

[](#-installation)

Install via Composer from [Packagist](https://packagist.org/packages/modelslab/octane-coroutine):

```
composer require modelslab/octane-coroutine
```

Then install Octane with Swoole:

```
php artisan octane:install swoole
```

### Specific Version

[](#specific-version)

```
# Install latest stable
composer require modelslab/octane-coroutine:^0.8.7

# Install development version
composer require modelslab/octane-coroutine:dev-main
```

### Updating the Package

[](#updating-the-package)

```
# Update to the latest version
composer update modelslab/octane-coroutine

# Clear caches after updating
php artisan config:clear
php artisan cache:clear
php artisan octane:reload
```

**Tip**: Pin your production deployments to specific versions:

```
{
    "require": {
        "modelslab/octane-coroutine": "^0.8.7"
    }
}
```

🔧 Configuration
---------------

[](#-configuration)

The package works out-of-the-box with sensible defaults. Coroutines are **enabled by default** with runtime hooks.

### Worker Configuration

[](#worker-configuration)

Start with appropriate worker count:

```
# Development (auto-detect CPU cores)
php artisan octane:start --server=swoole

# Production (explicit worker count)
php artisan octane:start --server=swoole --workers=32
```

### Advanced Configuration

[](#advanced-configuration)

Edit `config/octane.php` if needed:

```
'swoole' => [
    'options' => [
        'enable_coroutine' => true,  // Already enabled by default
        'worker_num' => 32,
        'max_request' => 10000,
        'max_request_grace' => 1000,
    ],
],
```

### Redis & Database Coroutine Safety

[](#redis--database-coroutine-safety)

Coroutine mode relies on coroutine-safe IO drivers and connection handling. Recommended defaults:

```
# Redis
REDIS_CLIENT=phpredis

# Database (disable PDO persistent connections in coroutine mode)
DB_PERSISTENT=false

# Database pool cleanup. Keep these enabled in production so burst-created
# idle sockets are pruned instead of retained until worker shutdown.
DB_POOL_HEARTBEAT=10
DB_POOL_MAX_IDLE_TIME=60

# Redis persistent sockets are unsafe for request-scoped coroutine managers.
REDIS_PERSISTENT=false
REDIS_SESSION_PERSISTENT=false

# Optional startup warning buffer for DB min_connections planning
OCTANE_POOL_DB_MAX_CONNECTIONS_BUFFER=10
```

Notes:

- **phpredis** is fastest. This fork rewrites Redis handling for coroutine safety so request-scoped Redis managers do not reuse process-shared persistent sockets.
- **Predis** is not included by default. If you prefer a PHP-only client, install it manually and disable persistence:
    - `composer require predis/predis`
    - `REDIS_CLIENT=predis`
    - `REDIS_PERSISTENT=false`
- **PDO persistent connections** can cause cross-coroutine contention; keep them off.
- **DB pool max connections are per worker**. The effective upper bound is `workers × DB_POOL_MAX_CONNECTIONS`, so size the pool below your database server's `max_connections` budget.
- **Long external waits should not hold backend sockets**. For AI/API workloads that wait 60-120 seconds on an upstream provider, release DB/Redis handles before the external wait whenever the request no longer needs them.
- Database connection pooling in `config/database.php` is separate from the HTTP runtime. The only `octane.swoole.pool` setting still used is the DB warning buffer above.

### v0.8.7 Production Hardening

[](#v087-production-hardening)

Version `v0.8.7` includes the production hardening used for high-concurrency AI API workloads:

- `app()->handle()` subrequests now resolve the coroutine-scoped HTTP kernel/router and temporarily swap request bindings only inside the current request scope. This prevents JSON/form/base64 API subrequests from corrupting method, body, query, headers, or the outer `request()` helper.
- The DB pool rolls back dirty Laravel and PDO transactions before reuse.
- Idle DB sockets are pruned by heartbeat / max-idle settings.
- Worker termination releases coroutine DB connections before request scope is flushed, preventing stale pool counters after dirty requests.
- Request-scoped Redis/cache/session managers are released so sockets do not leak between coroutines.

Regression coverage for this release includes concurrent request isolation, nested API shape preservation, request-time container binding isolation, locale/translator isolation, Redis manager isolation, dirty DB transaction cleanup, and DB idle pruning.

### Validated Stress Results

[](#validated-stress-results)

The `v0.8.7` release was validated in Docker with host-network MySQL and Redis:

- App full suite: `1883 passed`, `2 skipped`, `5446 assertions`.
- Package suite: `82 tests`, `687 assertions`.
- Fast full-stack wrk: `7912/7912` PASS, zero leaks/errors.
- Nested API `app()->handle()` wrk: `15860/15860` PASS, zero leaks/errors.
- Remote file parity wrk: `4049/4049` PASS, zero leaks/errors.
- Dirty DB transaction open/check wrk: `15894` dirty opens followed by `15654`clean checks at transaction level `0`, zero leaks/errors.
- Mixed 0-60s full-stack wrk: `458/458` PASS, zero leaks/errors.
- Fixed-count `10k x 120s` full-stack blocking IO: `10000/10000` valid JSON `200`, zero leak responses.

After stress, MySQL and Redis returned to baseline (`Threads_connected=1`, `connected_clients=1`) with no container log stack traces.

🏊 Understanding Workers and Coroutines
--------------------------------------

[](#-understanding-workers-and-coroutines)

This section clarifies the key concepts that make this fork different from standard Octane.

### What are Workers?

[](#what-are-workers)

**Workers** are OS-level processes spawned by Swoole. Each worker:

- Is a separate PHP process with its own memory space
- Can handle requests independently
- Is configured via `--workers=N` or `worker_num` in config

```
Standard Octane: 1 Worker = 1 Request at a time (blocking)

```

### What are Coroutines?

[](#what-are-coroutines)

**Coroutines** are lightweight, cooperative "threads" managed by Swoole at the application level (not OS-level). When a coroutine encounters blocking I/O, it **yields** control to other coroutines instead of blocking the entire worker.

```
Traditional: Worker blocks → other requests wait
Coroutines:  Worker yields → other requests continue

```

### How They Work Together

[](#how-they-work-together)

```
┌─────────────────────────────────────────────────────────────┐
│                     SWOOLE SERVER                           │
├─────────────────────────────────────────────────────────────┤
│  Worker 0                      Worker 1                     │
│  ┌─────────────────────┐       ┌─────────────────────────┐  │
│  │ Shared Laravel      │       │ Shared Laravel          │  │
│  │ worker runtime      │       │ worker runtime          │  │
│  │                     │       │                         │  │
│  │ Coroutines:         │       │ Coroutines:             │  │
│  │ cid:1 → scope A     │       │ cid:1 → scope A         │  │
│  │ cid:2 → scope B     │       │ cid:2 → scope B         │  │
│  │ cid:3 → scope C     │       │ cid:3 → scope C         │  │
│  │ ...                 │       │ ...                     │  │
│  └─────────────────────┘       └─────────────────────────┘  │
└─────────────────────────────────────────────────────────────┘

```

### How Request Isolation Works

[](#how-request-isolation-works)

This runtime does **not** use an HTTP application pool anymore. Each Swoole worker boots one shared Laravel worker runtime, and concurrent requests are isolated by the coroutine-aware container proxy plus per-request scoped state for bindings such as request, session, router, view, log, cache, and Redis managers.

The legacy `octane.swoole.pool` config namespace remains only for `db_max_connections_buffer`, which is used by a startup safety warning.

🧪 Testing
---------

[](#-testing)

Unit tests require a PHP build with the Swoole extension installed.

```
php83 vendor/bin/phpunit --testsuite Unit
```

### Coroutine Runtime Configuration

[](#coroutine-runtime-configuration)

The package is pool-free for HTTP workers. The relevant Swoole config looks like:

```
'swoole' => [
    'options' => [
        'worker_num' => 8,
    ],

    'pool' => [
        'db_max_connections_buffer' => env('OCTANE_POOL_DB_MAX_CONNECTIONS_BUFFER', 10),
    ],
],
```

`OCTANE_POOL_DB_MAX_CONNECTIONS_BUFFER` only affects the startup warning that checks MySQL `max_connections` against your configured database pool minimums.

⚡ Performance Optimization
--------------------------

[](#-performance-optimization)

### CPU Usage and Tick Timers

[](#cpu-usage-and-tick-timers)

**Following Hyperf/Swoole best practices**, this fork **disables tick timers by default** to prevent unnecessary CPU usage.

#### What are Tick Timers?

[](#what-are-tick-timers)

Octane can dispatch "tick" events to task workers every second. However:

- **Tick is disabled by default** (`'tick' => false` in `config/octane.php`)
- **Task workers are set to 0 by default** when tick is disabled
- This prevents **100% CPU usage** from idle task workers waking up every second

#### Why Disable Tick?

[](#why-disable-tick)

In earlier configurations, tick timers with `--task-workers=auto` would create one task worker per CPU core (e.g., 12 workers on a 12-core system). Even with no traffic:

```
12 task workers × tick every 1 second = constant CPU overhead

```

This causes high CPU usage even when the server is idle!

#### When to Enable Tick

[](#when-to-enable-tick)

Only enable tick if you have **listeners for `TickReceived` or `TickTerminated` events** that need to run periodically:

```
// config/octane.php
'swoole' => [
    'tick' => true,  // Enable tick timers
],
```

Then start with **minimal task workers** (not auto):

```
# Good: Only 1-2 task workers for tick
php artisan octane:start --task-workers=1

# Bad: Creates CPU_COUNT task workers (excessive overhead)
php artisan octane:start --task-workers=auto
```

#### Task Worker Guidelines

[](#task-worker-guidelines)

ScenarioRecommended `--task-workers`Tick disabled (default)`0` (auto)Tick enabled`1` or `2`Heavy async task dispatch`2` to `4`Never use`auto` (causes CPU overhead)📊 Performance Benchmarks
------------------------

[](#-performance-benchmarks)

Real-world load testing results with `wrk`:

### Baseline (No Coroutines)

[](#baseline-no-coroutines)

```
wrk -t12 -c2000 -d30s http://localhost:8000/test
```

- **Workers**: 8
- **Result**: 7.71 req/s

### With Coroutines Enabled

[](#with-coroutines-enabled)

```
wrk -t12 -c20000 -d60s http://localhost:8000/test
```

- **Workers**: 32
- **Result**: 2,773.34 req/s
- **Improvement**: **360×**

### Per-Worker Efficiency

[](#per-worker-efficiency)

ConfigurationReq/sec per workerConcurrent requests per workerStandard Octane~11With Coroutines~87~87Each worker can efficiently handle **~87 concurrent requests** thanks to coroutines!

🏗️ Architecture
---------------

[](#️-architecture)

### Runtime Hooks

[](#runtime-hooks)

Enabled automatically on worker start:

```
// src/Swoole/Handlers/OnWorkerStart.php
\Swoole\Runtime::enableCoroutine(SWOOLE_HOOK_ALL);
```

This converts all blocking I/O to coroutine-safe operations without any code changes required.

### Worker Initialization

[](#worker-initialization)

Workers log their initialization for monitoring:

```
🚀 Worker #0 starting initialization...
✅ Worker #0 (PID: 4958) initialized and ready!

```

### Graceful Degradation

[](#graceful-degradation)

If a worker isn't ready, requests receive `503` responses until initialization completes:

```
{
  "error": "Service Unavailable",
  "message": "Worker not initialized yet",
  "worker_id": 5
}
```

🎯 When to Use This Fork
-----------------------

[](#-when-to-use-this-fork)

### ✅ Perfect For:

[](#-perfect-for)

- Applications with **external API calls** (payment gateways, third-party services)
- **Database-heavy** applications with long queries
- **High-concurrency** requirements (1,000+ concurrent users)
- Applications performing **file I/O** (uploads, processing)
- Any app with **blocking operations** that can benefit from async

### ⚠️ Standard Octane is Fine For:

[](#️-standard-octane-is-fine-for)

- Purely **CPU-bound** operations (image processing, calculations)
- **Ultra-fast** responses (<50ms average)
- **Low-concurrency** requirements (<100 concurrent users)

🔍 Monitoring
------------

[](#-monitoring)

### Worker Logs

[](#worker-logs)

Check worker initialization in your logs:

```
tail -f storage/logs/swoole_http.log | grep "Worker"
```

### Performance Metrics

[](#performance-metrics)

Monitor your application:

- **5xx rate**: Watch for upstream or worker errors under load
- **Memory usage**: ~50-200MB per worker depending on application
- **Worker count**: Scale based on CPU cores (typically 1-2× CPU count)
- **Worker restarts**: Unexpected churn usually means a fatal error or memory issue

🛠️ Production Recommendations
-----------------------------

[](#️-production-recommendations)

### Resource Planning

[](#resource-planning)

```
Memory needed ≈ workers × 100-200MB per worker

```

**Example**: 32 workers = 3.2-6.4GB RAM

### OS Tuning

[](#os-tuning)

For high concurrency (10,000+ connections):

```
# Increase file descriptor limits
ulimit -n 65536

# Add to /etc/security/limits.conf
* soft nofile 65536
* hard nofile 65536
```

### Swoole Configuration

[](#swoole-configuration)

For extreme load:

```
// config/octane.php
'swoole' => [
    'options' => [
        'worker_num' => 64,
        'backlog' => 65536,
        'socket_buffer_size' => 2097152,
    ],
],
```

🐛 Debugging
-----------

[](#-debugging)

Enable debug logging to track worker behavior:

```
// Check worker initialization
tail -f storage/logs/swoole_http.log

// Monitor in real-time
php artisan octane:start --server=swoole --workers=32 | grep "Worker"
```

⚠️ Important Notes
------------------

[](#️-important-notes)

- **Database connections**: Ensure `max_connections` can handle your concurrency
- **Memory**: Monitor usage and scale workers accordingly
- **Warmup**: Workers initialize automatically; allow 5-10 seconds before heavy load
- **State management**: Laravel's service container handles coroutine isolation automatically
- **Proxy timeouts**: If you're behind Nginx/ALB, set upstream read timeouts above your max request time

📈 Scaling Guide
---------------

[](#-scaling-guide)

### Small (Development)

[](#small-development)

- Workers: 4-8
- Handles: ~500 concurrent requests
- RAM: 2-4GB

### Medium (Production)

[](#medium-production)

- Workers: 16-32
- Handles: ~2,000 concurrent requests
- RAM: 4-8GB

### Large (High-Traffic)

[](#large-high-traffic)

- Workers: 32-64
- Handles: ~5,000 concurrent requests
- RAM: 8-16GB

### XL (Enterprise)

[](#xl-enterprise)

- Workers: 64-128
- Handles: ~10,000+ concurrent requests
- RAM: 16-32GB

🎯 Recommended Configuration: 8-Core CPU for 10K req/sec
-------------------------------------------------------

[](#-recommended-configuration-8-core-cpu-for-10k-reqsec)

This section provides specific, tested recommendations for achieving **10,000 requests/second** on an 8-core CPU.

### Understanding the Math

[](#understanding-the-math)

```
For 10K req/sec with 100ms average response time:
- Concurrent requests needed: 10,000 × 0.1 = 1,000 concurrent
- With 8 workers, each needs: 1,000 ÷ 8 = 125 concurrent per worker
- There is no HTTP app pool cap; the real limits are memory, upstream capacity,
  and whether your request path actually yields on blocking I/O.

```

### Recommended Configuration

[](#recommended-configuration)

```
// config/octane.php
'swoole' => [
    'options' => [
        'worker_num' => 8,              // Match CPU cores
        'max_request' => 10000,         // Restart worker after N requests (memory safety)
        'max_request_grace' => 1000,    // Grace period for graceful restart
        'backlog' => 8192,              // Connection queue size
        'socket_buffer_size' => 2097152, // 2MB socket buffer
        'buffer_output_size' => 2097152, // 2MB output buffer
    ],
],
```

### Start Command

[](#start-command)

```
php artisan octane:start \
    --server=swoole \
    --workers=8 \
    --task-workers=0 \
    --max-requests=10000 \
    --port=8000
```

### Resource Requirements

[](#resource-requirements)

ResourceMinimumRecommendedCPU8 cores8+ coresRAM8GB16GBFile Descriptors65536100000+Network1Gbps10Gbps### Memory Calculation

[](#memory-calculation)

```
Memory ≈ worker count × base worker footprint + in-flight request state

Measure this under real load in your application. Pool-free coroutine mode is
dramatically lighter than pre-booting many application instances per worker, but
the exact number still depends on your middleware, services, and payload sizes.

```

### Database Connection Pooling

[](#database-connection-pooling)

Database pooling is separate from the HTTP runtime. Size it from worker count and your configured per-connection pool minimums and maximums.

```
// config/database.php
'mysql' => [
    'driver' => 'mysql',
    // ... other config
    'pool' => [
        'min_connections' => 1,
        'max_connections' => 50,
        'connect_timeout' => 10.0,
        'wait_timeout' => 3.0,
    ],
],
```

For example, `8 workers × min_connections=1` means at least `8` DB connections before real traffic. `OCTANE_POOL_DB_MAX_CONNECTIONS_BUFFER` only adjusts the startup warning threshold for this planning.

Or configure MySQL server:

```
SET GLOBAL max_connections = 500;
SET GLOBAL wait_timeout = 28800;
```

### OS Tuning for 10K req/sec

[](#os-tuning-for-10k-reqsec)

```
# /etc/sysctl.conf
net.core.somaxconn = 65535
net.core.netdev_max_backlog = 65535
net.ipv4.tcp_max_syn_backlog = 65535
net.ipv4.ip_local_port_range = 1024 65535
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_fin_timeout = 15
net.core.rmem_max = 16777216
net.core.wmem_max = 16777216

# Apply changes
sysctl -p
```

```
# /etc/security/limits.conf
* soft nofile 100000
* hard nofile 100000
* soft nproc 65535
* hard nproc 65535

# Apply (requires re-login)
ulimit -n 100000
```

### Benchmark Expectations

[](#benchmark-expectations)

With the above configuration on 8-core CPU:

ScenarioExpected req/secSimple JSON response15,000-20,000Database SELECT (cached)8,000-12,000Database SELECT (no cache)3,000-6,000External API call (100ms)8,000-10,000Complex business logic5,000-8,000### Tuning Tips

[](#tuning-tips)

1. **Start Conservative**: Begin with a modest worker count and measure under load
2. **Monitor Actively**: Watch memory, 5xx rates, worker restarts, and upstream saturation
3. **Warm Up**: Allow 30-60 seconds for workers to warm up before heavy traffic
4. **Use Redis**: Offload sessions and cache to Redis for better concurrency
5. **Size Database Pools Separately**: Prevent DB connection exhaustion independently of HTTP concurrency

📚 Resources
-----------

[](#-resources)

- [Laravel Octane Documentation](https://laravel.com/docs/octane)
- [Swoole Documentation](https://www.swoole.co.uk/docs)
- [Coroutine Programming Guide](https://www.swoole.co.uk/docs/modules/swoole-coroutine)

🤝 Contributing
--------------

[](#-contributing)

Contributions are welcome! Please read the [contribution guide](.github/CONTRIBUTING.md).

🔒 Security
----------

[](#-security)

Please review [our security policy](https://github.com/laravel/octane/security/policy) to report vulnerabilities.

📄 License
---------

[](#-license)

This fork maintains the original MIT license. See [LICENSE.md](LICENSE.md).

---

**Built with ❤️ by [ModelsLab](https://github.com/ModelsLab)**

**Original Laravel Octane** by Taylor Otwell and the Laravel team

###  Health Score

47

—

FairBetter than 93% of packages

Maintenance94

Actively maintained with recent releases

Popularity27

Limited adoption so far

Community9

Small or concentrated contributor base

Maturity46

Maturing project, gaining track record

 Bus Factor1

Top contributor holds 96.8% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Every ~7 days

Recently: every ~17 days

Total

35

Last Release

14d ago

### Community

Maintainers

![](https://www.gravatar.com/avatar/9dcb9f78e0cc477dbb503c2402ae0e245dc7aa983fb079c09805ad880fb37d0d?d=identicon)[anuragkanade12](/maintainers/anuragkanade12)

---

Top Contributors

[![adhikjoshi](https://avatars.githubusercontent.com/u/11740719?v=4)](https://github.com/adhikjoshi "adhikjoshi (61 commits)")[![devsahm](https://avatars.githubusercontent.com/u/47601167?v=4)](https://github.com/devsahm "devsahm (2 commits)")

---

Tags

laravelswooleasyncnon-blockinglaravelperformanceswooleoctanecoroutine

###  Code Quality

TestsPHPUnit

Static AnalysisPHPStan

Type Coverage Yes

### Embed Badge

![Health badge](/badges/modelslab-octane-coroutine/health.svg)

```
[![Health](https://phpackages.com/badges/modelslab-octane-coroutine/health.svg)](https://phpackages.com/packages/modelslab-octane-coroutine)
```

###  Alternatives

[laravel/octane

Supercharge your Laravel application's performance.

4.0k28.5M262](/packages/laravel-octane)[laravel/framework

The Laravel Framework.

34.9k556.2M21.5k](/packages/laravel-framework)[statamic/cms

The Statamic CMS Core Package

4.9k3.8M1.2k](/packages/statamic-cms)[laravel/horizon

Dashboard and code-driven configuration for Laravel queues.

4.2k99.8M355](/packages/laravel-horizon)[laravel/nightwatch

The official Laravel Nightwatch package.

36911.6M45](/packages/laravel-nightwatch)[laravel/ai

The official AI SDK for Laravel.

1.1k4.6M328](/packages/laravel-ai)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)