Run Laravel, WordPress and PHP projects with independent PHP runtimes, Apache or Nginx, MySQL, Redis-compatible caching, Mailpit, Composer, Node.js, HTTPS, databases, logs and background tasks - without turning your development environment into a pile of disconnected terminal windows.
Rumi Stack turns local development into a visual system: project state, runtime state, service endpoints, readiness, tasks and actions stay visible in context.
Every screen is purpose-built for a job developers actually do: bring in projects, select runtimes, start services, inspect dependencies, manage data, run tools and understand what is happening when something takes time.
A SwiftUI workspace with a visual sidebar, dashboard metrics, native file dialogs, confirmations, menu-bar controls, scoped status, settings, logs and task activity. No browser wrapper standing between you and your local stack.
Install and inspect multiple PHP branches, register compatible custom runtimes, view module and INI details, and bind each site to the runtime it actually needs.
Choose the web server that fits the project. Rumi Stack generates local server configuration and connects it to the site's PHP-FPM runtime.
Create MySQL databases and local users, list tables, run SQL, import and export dumps, or create SQLite databases without leaving the app.
Composer, Artisan, npm, frontend builds, queue workers, scheduler processes, WP-CLI access and project-aware terminals live next to the project they belong to.
Long-running work has real stages, bounded live output, a resource-aware queue, independent task slots, cancellation, retained results and retry. Installation and maintenance stop feeling like mysterious modal spinners.
Import an existing project folder or create a Laravel project, then choose PHP, server, document root, ports and HTTPS. The everyday view stays focused on Start, Stop and Open; advanced controls remain available when you need them.
Trust is explicit. A project can be registered without allowing its code to run. Start actions remain blocked until you decide the folder is trusted.
HTTPS is a real site setting in Rumi Stack, not a command you have to reconstruct every time. Give each project its own HTTPS port and Rumi Stack generates the localhost certificate path for the build you are using.
Per-site HTTPSEnable TLS independently for each Laravel, WordPress or PHP project.
Private local CAApp Store builds create their own local CA and signed localhost certificates with bundled OpenSSL.
Explicit browser trustExport or trust the public local CA intentionally. Rumi Stack does not silently change macOS trust settings.
Loopback SANsLocal certificates cover localhost and loopback addresses used by the managed web stack.
Shared services get a clean lifecycle, visible connection details and safe local defaults. Rumi Stack checks its own endpoints and avoids taking over unrelated processes.
Rumi Stacklocal service coordinator
Rumi Stack is built around runtime choice instead of forcing every site onto one PHP installation. Inspect exact runtime details and add project-specific extensions only where you need them.
Local database work sits beside your projects and services. Create app databases, issue scoped local grants, inspect tables, import or export SQL, update user passwords and work with a built-in query console.
The workflow is designed around what happens after you choose a folder: trust it, give it the right runtime, bring up dependencies, then use project-specific tools without losing context.
Import a folder or create a Laravel project.
Assign PHP and Apache or Nginx.
Keep code stopped until you approve execution.
Bring up MySQL, cache or Mailpit as needed.
Open the site, terminal and project tools.
Create a project, inspect environment readiness, run Composer and Artisan actions, manage migrations and cache, create storage links and app keys, and control queue, scheduler, Vite and Reverb processes.
Recognize WordPress projects, work with local database setup and wp-config.php, open WP Admin, inspect wp-content and access WP-CLI from the site's PHP-aware terminal.
Use Apache or Nginx, custom document roots and local ports for generic PHP applications or projects adapted from shared-hosting and cPanel environments.
Run CodeIgniter projects with custom document roots, selectable PHP versions, local databases, cache services and a PHP-aware terminal for framework maintenance tasks.
Bring legacy Zend Framework sites and modern Laminas applications into a managed local stack with version-appropriate PHP, Composer workflows and Apache or Nginx.
Develop Drupal sites locally with MySQL, local mail capture, flexible web-server choices, HTTPS support and per-project runtime isolation.
Power Joomla builds with managed PHP, database setup, local SMTP testing, custom ports and document-root flexibility for clean local hosting.
Composer-based PHP apps such as Symfony, Slim, CakePHP and other frameworks can run in the same local workspace with server, runtime and service control per site.
Installations, builds, Composer commands, database actions and maintenance tasks report real stages instead of leaving you with an indeterminate progress spinner.
The 1.5.11 application goes well beyond starting a web server. These workflows are built into the native UI and now have a visual home on the site.
The bundled runtime path includes PHP, Nginx + OpenSSL, MySQL, Redis-compatible Valkey, Mailpit, Memcached, Node.js/npm, Composer and WP-CLI. No Docker or VM is required to coordinate the stack.
Rumi Stack inspects WordPress readiness, can build database configuration, repair broken bootstrap cases, preserve the previous wp-config.php as a backup, open WP Admin and expose WP-CLI in the project-aware terminal.
The System Status screen checks whether shared services are both running and reachable, inspects PHP module readiness, shows managed process IDs and links directly into live logs and Activity output.
Start or stop individual sites and shared services, open projects, jump back into Rumi Stack, or stop everything from a native menu-bar extra. Closing the main window does not have to interrupt running services.
Rumi Stack understands shared-hosting-shaped projects, including alternate document roots such as public_html, then lets you pair them with a modern PHP runtime, local database, web server and HTTPS settings.
For managed deployments, a configured HTTPS control plane can approve the app, hide whole screens, sections or individual functions, and cache policy for an administrator-defined offline window. Native action paths enforce the same policy instead of relying only on hidden buttons.
This is deployment policy-not remote execution of a developer's project code.Rumi Stack's process model emphasizes non-privileged local services, loopback listeners, owned process groups, private runtime paths, explicit trust and safe port handling.
Managed service endpoints are intended for 127.0.0.1, keeping normal development traffic on the Mac.
Runtime Unix sockets are namespaced per workspace so unrelated Rumi Stack sessions do not fight over shared socket paths.
If another process already owns a preferred managed-service port, Rumi Stack can select another free port from its private range rather than stopping the external process.
The managed process model uses a non-privileged helper and owned process groups instead of launching local web servers with administrator privileges.
Local MySQL credentials are stored for the workspace, and protected credential operations are deliberately excluded from streamed task output.
Projects can be added to the workspace without immediately running their code. Execution stays under your control until you choose to trust and start the project.
Rumi Stack includes a private localhost PHP test site that exercises the same managed web server and PHP-FPM path as your projects. It can report readiness for frameworks, supporting services, developer tools and browser capabilities from one diagnostic page.
Powerful enough for daily application work, organized enough that advanced controls do not overwhelm the everyday flow.
Multiple local projects
Apache + Nginx
PHP-FPM per site
Independent HTTP / HTTPS ports
Private localhost certificates
Public Local CA export / trust
Generated configuration
Project trust
Multiple PHP branches
Custom runtime registration
PHP info + INI locations
Optional PHP extensions
Composer workflows
Node.js / npm
Bundled WP-CLI
PHP-aware Terminal
Laravel project creation
Artisan + migrations
Queue / scheduler / Vite / Reverb
WordPress detection + repair
WP Admin + wp-config setup
Built-in environment test
cPanel/shared-hosting migration
Custom document roots
MySQL 8.4 runtime
Database + user creation
SQL console
Import / export
SQLite creation
Redis-compatible Valkey
Mailpit inbox + SMTP
Optional Memcached
Live task stages
Resource-aware task queue
Cancellation + safe retry
Incremental logs
Live endpoint health checks
PHP module readiness
Managed process details
Native menu-bar controls
Loopback-only listeners
Workspace-private sockets
Port ownership checks
Non-privileged server startup
Credential-safe task output
Global stop controls
Remote policy gates
Offline policy cache window
These answers reflect the functionality present in the supplied Rumi Stack 1.5.11 project.
It consolidates the local development control plane: project registration, site lifecycle, PHP runtimes, web servers, supporting services, databases, project tools, logs and long-running task activity. Your actual frameworks, source code and familiar command-line tools remain the underlying technologies.
Yes. Each site stores its selected PHP branch and runs its own web/PHP process configuration. Multiple PHP runtimes can be installed in the same workspace.
Yes. Sites can use Apache with rewrite and .htaccess behavior or Nginx with FastCGI/front-controller configuration, depending on the project.
HTTPS can be enabled per site with its own local port. In the App Store runtime path, Rumi Stack generates a private local CA and localhost certificates and lets you export only the public CA for browser trust. Direct-download builds use the local CA trust workflow. The app does not silently alter macOS trust settings.
It is an optional managed-deployment policy layer. A configured HTTPS backend can approve the app and control which screens, sections and functions are exposed. The same checks are enforced by native action paths, not just by hiding controls in the interface.
MySQL is a shared local service inside the workspace, while databases and application users are created separately. Rumi Stack exposes database and user management so projects can have isolated schemas and credentials.
For managed services, the current project includes port-availability checks and private fallback ranges. It avoids killing or reusing an unrelated process simply because that process owns a preferred port.
No. The application interface is implemented natively in SwiftUI for macOS. The local sites it runs are normal web projects, but the workspace itself is a native Mac app.
RUMI STACKProjects, runtimes, web servers, databases, supporting services and developer tools - visible together, controllable together, still running on your Mac.