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.4(3mo ago)2281[1 issues](https://github.com/ModelsLab/octane-coroutine/issues)MITPHPPHP ^8.1.0CI passing

Since Nov 22Pushed 3mo 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 1mo ago

READMEChangelog (10)Dependencies (21)Versions (22)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.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.7.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' => 500,
    ],
],
```

### 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
REDIS_PERSISTENT=true

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

# Pool sizing (keep min low to avoid exhausting MySQL max_connections)
DB_POOL_MIN=1
DB_POOL_MAX=50
```

Notes:

- **phpredis** is fastest, but persistence must be isolated per worker. This fork assigns a unique `persistent_id` per pool worker to avoid socket sharing across coroutines.
- **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.

🏊 Understanding Workers, Pool, and Coroutines
---------------------------------------------

[](#-understanding-workers-pool-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 is the Application Pool?

[](#what-is-the-application-pool)

The **Pool** is a collection of pre-initialized Laravel Application instances within each worker. This fork introduces pooling to solve state isolation:

```
This Fork: 1 Worker = 1 Pool of N Application instances

```

When a coroutine needs to handle a request, it borrows an Application from the pool, uses it, then returns it. This ensures:

- **State Isolation**: Each concurrent request gets its own Application instance
- **No State Leakage**: Request A's data never bleeds into Request B
- **Memory Efficiency**: Applications are reused, not created per-request

### 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                     │
│  ┌─────────────────────┐       ┌─────────────────────────┐  │
│  │ Pool (10 Apps)      │       │ Pool (10 Apps)          │  │
│  │ ┌───┐┌───┐┌───┐     │       │ ┌───┐┌───┐┌───┐        │  │
│  │ │App││App││App│ ... │       │ │App││App││App│ ...    │  │
│  │ └───┘└───┘└───┘     │       │ └───┘└───┘└───┘        │  │
│  │                     │       │                         │  │
│  │ Coroutines:         │       │ Coroutines:             │  │
│  │ cid:1 → App[0]      │       │ cid:1 → App[0]          │  │
│  │ cid:2 → App[1]      │       │ cid:2 → App[1]          │  │
│  │ cid:3 → App[2]      │       │ cid:3 → App[2]          │  │
│  │ ...                 │       │ ...                     │  │
│  └─────────────────────┘       └─────────────────────────┘  │
└─────────────────────────────────────────────────────────────┘

```

### Are Coroutines and Pool the Same?

[](#are-coroutines-and-pool-the-same)

**No!** They solve different problems:

ConceptWhat It DoesSolves**Coroutines**Non-blocking I/O, concurrent executionPerformance (throughput)**Pool**Pre-initialized Application instancesState isolation (correctness)- **Coroutines without Pool**: Fast but dangerous (state leaks between requests)
- **Pool without Coroutines**: Safe but slow (one request at a time)

🧪 Testing
---------

[](#-testing)

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

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

- **Both together**: Fast AND safe ✅

### Pool Configuration

[](#pool-configuration)

This fork adds a new `pool` configuration section to `config/octane.php`:

```
'swoole' => [
    'options' => [
        'worker_num' => 8,  // OS processes (CLI: --workers=8)
    ],

    // NEW: Application pool per worker
    'pool' => [
        'size' => 100,      // Applications per worker
        'min_size' => 1,    // Minimum pool size
        'max_size' => 1000, // Maximum pool size
        'idle_timeout' => 10, // Seconds before trimming idle workers
    ],
],
```

**Note**: Standard Octane only has `worker_num`. The `pool` configuration is unique to this fork.

You can also configure the pool via `.env`:

```
OCTANE_POOL_SIZE=50
OCTANE_POOL_MIN_SIZE=1
OCTANE_POOL_MAX_SIZE=1000
OCTANE_POOL_IDLE_TIMEOUT=10
OCTANE_POOL_WAIT_TIMEOUT=30
OCTANE_POOL_REJECT_ON_FULL=false
OCTANE_POOL_OVERLOAD_STATUS=503
OCTANE_POOL_OVERLOAD_RETRY_AFTER=5
OCTANE_POOL_DB_MAX_CONNECTIONS_BUFFER=10
```

Notes:

- `OCTANE_POOL_WAIT_TIMEOUT` controls how long a request can wait for a pooled app before an overload response is returned.
- `OCTANE_POOL_REJECT_ON_FULL=true` disables queuing and immediately returns `OCTANE_POOL_OVERLOAD_STATUS`.

⚡ 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:

- **503 rate**: Should be <1% in production (indicates capacity issues)
- **Memory usage**: ~50-200MB per worker depending on application
- **Worker count**: Scale based on CPU cores (typically 1-2× CPU count)

🛠️ 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 plus any expected queueing

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

[](#-scaling-guide)

### Small (Development)

[](#small-development)

- Workers: 4-8
- Pool Size: 10-20
- Handles: ~500 concurrent requests
- RAM: 2-4GB

### Medium (Production)

[](#medium-production)

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

### Large (High-Traffic)

[](#large-high-traffic)

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

### XL (Enterprise)

[](#xl-enterprise)

- Workers: 64-128
- Pool Size: 200-500
- 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)

```
Total Concurrent Capacity = Workers × Pool Size × Coroutine Efficiency

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
- Pool size recommendation: 150-200 (with buffer)

```

### 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
    ],

    'pool' => [
        'size' => 200,                  // 200 apps per worker = 1,600 total capacity
        'min_size' => 10,
        'max_size' => 500,
        'idle_timeout' => 10,
    ],
],
```

### 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 per Worker ≈ Base (50MB) + (Pool Size × App Memory)
Memory per App ≈ 10-30MB (depends on your application)

Example with pool size 200:
- Per worker: 50MB + (200 × 15MB) = ~3GB
- 8 workers: 8 × 3GB = ~24GB peak

Note: This is peak memory. Actual usage is lower as apps share memory.
Realistic: 8-12GB for 8 workers with pool size 200

```

### Database Connection Pooling

[](#database-connection-pooling)

**Critical**: With 8 workers × 200 pool size, you could have up to 1,600 concurrent database connections!

```
// config/database.php
'mysql' => [
    'driver' => 'mysql',
    // ... other config
    'pool' => [
        'min_connections' => 1,
        'max_connections' => 50,  // Per worker: 8 × 50 = 400 max connections
        'connect_timeout' => 10.0,
        'wait_timeout' => 3.0,
    ],
],
```

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 pool size 50, increase gradually while monitoring memory
2. **Monitor Actively**: Watch for pool exhaustion (503 errors) and memory growth
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. **Connection Pooling**: Use database connection pooling to prevent connection exhaustion

### Comparison: Workers vs Pool Scaling

[](#comparison-workers-vs-pool-scaling)

StrategyConfigCapacityMemoryBest ForMore Workers16 workers × 50 pool800 concurrent~8GBCPU-bound workLarger Pool8 workers × 200 pool1,600 concurrent~10GBI/O-bound workBalanced12 workers × 100 pool1,200 concurrent~9GBMixed workloads**Rule of Thumb**:

- **I/O-heavy apps** (APIs, database): Fewer workers, larger pool
- **CPU-heavy apps** (processing): More workers, smaller pool

📚 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

35

—

LowBetter than 80% of packages

Maintenance69

Regular maintenance activity

Popularity11

Limited adoption so far

Community7

Small or concentrated contributor base

Maturity43

Maturing project, gaining track record

 Bus Factor1

Top contributor holds 100% 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 ~3 days

Total

21

Last Release

116d 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 (34 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.0k21.5M159](/packages/laravel-octane)[laravel/framework

The Laravel Framework.

34.6k509.9M17.0k](/packages/laravel-framework)[hhxsv5/laravel-s

🚀 LaravelS is an out-of-the-box adapter between Laravel/Lumen and Swoole.

3.9k676.0k10](/packages/hhxsv5-laravel-s)[mpbarlow/laravel-queue-debouncer

A wrapper job for debouncing other queue jobs.

63714.4k1](/packages/mpbarlow-laravel-queue-debouncer)[tochka-developers/queue-promises

Promises for Laravel queue jobs

1912.3k](/packages/tochka-developers-queue-promises)

PHPackages © 2026

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