Engine Laravel Package

Product Decisions This Supports

• High-Performance Microservices & APIs: Enables coroutine-based concurrency for Laravel/PHP applications, reducing latency and improving throughput for I/O-bound workloads (e.g., real-time APIs, WebSocket services, or event-driven architectures).
• Roadmap for Async PHP: Justifies investment in PHP’s async ecosystem by leveraging Swoole’s coroutine engine, aligning with Hyperf’s broader async-first framework. Useful for teams evaluating PHP’s future in high-concurrency environments.
• Build vs. Buy: Buy for teams needing coroutine support without rewriting core logic. Build only if custom coroutine behavior is required (e.g., proprietary scheduling).
• Use Cases:
  • Real-time systems: WebSocket servers, chat apps, or live notifications.
  • High-throughput APIs: Replacing synchronous HTTP clients with async calls to external services.
  • Background jobs: Offloading long-running tasks (e.g., image processing) without blocking requests.
  • Hybrid architectures: Integrating with existing Laravel apps via Hyperf’s bridge (e.g., hyperf/hyperf-laravel).

When to Consider This Package

• Adopt if:
  • Your PHP app requires sub-millisecond response times for I/O operations (e.g., DB queries, HTTP calls, or WebSocket messages).
  • You’re building event-driven or real-time systems where blocking requests degrade UX (e.g., gaming, financial tickers).
  • Your team is already using Swoole or Hyperf and needs a lightweight coroutine layer.
  • You’re evaluating PHP for high-performance workloads and want to avoid Go/Node.js.
• Look elsewhere if:
  • Your workload is CPU-bound (use PHP workers or offload to a queue like Redis/RabbitMQ).
  • You need full async/await syntax (consider Amphp or ReactPHP).
  • Your team lacks Swoole/Hyperf expertise (steep learning curve for coroutine debugging).
  • You’re constrained to shared hosting (Swoole requires a compatible server like swoole-php).
  • Your app is Laravel-only with no plans to adopt Hyperf (integration requires extra effort).

How to Pitch It (Stakeholders)

For Executives: "This package lets us run PHP at scale—like Node.js or Go—but with our existing codebase. For real-time features (e.g., live dashboards, chat apps), it cuts response times by 10x while keeping our team’s PHP skills. Early adopters like Hyperf use it to power high-traffic APIs, and the Swoole engine is battle-tested in China’s largest tech companies. Low risk: it’s a drop-in for I/O-heavy workloads, and we can phase it in alongside our Laravel apps."

For Engineering: *"Hyperf/Engine gives us Swoole’s coroutine engine as a standalone PHP package. Key benefits:

• Non-blocking I/O: Replace file_get_contents() with async go(fn() => ...) for HTTP/DB calls.
• WebSocket native support: Build real-time apps without Node.js (e.g., hyperf/websocket-server).
• Hyperf compatibility: If we adopt Hyperf later, this is the same engine—no rewrite.
• Laravel integration: Use it alongside Laravel via hyperf-laravel for async jobs or APIs. Tradeoff: Requires Swoole extension (not available on all hosts) and a shift to coroutine-based thinking. Start with a proof-of-concept for a high-impact endpoint (e.g., WebSocket gateway or API rate-limiting).*"

For Architects: *"This fills a gap in PHP’s async ecosystem. Unlike ReactPHP (event-loop) or Amp (fibers), Swoole’s coroutines are optimized for:

• High concurrency: 1M+ connections on a single machine (vs. ~10K with traditional PHP).
• Low latency: Coroutines yield control voluntarily, unlike threads.
• Mixed workloads: Run async code alongside synchronous Laravel logic. Recommendation: Pilot this for a new microservice (e.g., notifications) or upgrade an existing Hyperf app. Avoid monolithic Laravel apps unless you’re ready to refactor."*