Laminas: components, Mezzio and the MVC framework

What Laminas is

Laminas is a PHP framework project. Its documentation site presents several areas: Mezzio, a components collection, migration guides, tutorials, and an MVC framework. The only evidence used is the landing page of the official documentation, so anything that page does not state is marked unknown below.

Classification

Laminas is a framework and component collection. It is not a PHP runtime, not a PHP interpreter, and not a CMS. PHP itself (the language and the engine that executes it) is separate from Laminas, which is PHP code that runs on top of PHP. Laminas is also different from a CMS product such as Drupal: a CMS ships content management features and an administration experience, while a framework or component library gives you building blocks for your own application. The documentation page does not describe Laminas as a CMS, and this guide does not treat it as one.

The parts named in the documentation

• Mezzio: described as PSR-15 middleware in minutes. PSR-15 is a middleware standard, so Mezzio is a middleware-style application approach.
• Components: described as components for enterprise applications. These are individually documented libraries you can adopt, rather than one monolith.
• MVC: described as MVC for enterprise applications and labelled security-only maintenance mode. For new projects, weigh that label carefully and confirm the current state on the official site.
• Tutorials: cover creating laminas-mvc applications, in-depth component guides, and migration to version 3.
• Migration: covers moving an application or library to Laminas from Zend Framework, Expressive, or Apigility. Those are predecessor names. Treat them as historical, and do not start new production work on them.

Architecture and execution model

The landing page does not detail internals, so this is general framework context rather than a claim about specific Laminas APIs. In the classic PHP request lifetime, a web server hands each request to PHP, the application boots, handles the request, sends a response, and its memory is discarded. A framework such as laminas-mvc or a middleware application such as Mezzio normally fits this model: every request builds its own objects and nothing lingers in memory afterward.

Persistent workers are a different model. A long-running process boots the application once and serves many requests. That is a property of the surrounding runtime or adapter, not of the framework alone. The source does not say whether Laminas components or Mezzio support persistent workers, so that support is unknown. Do not assume it. Also keep runtimes apart: Swoole and Open Swoole are separate projects, and an adapter that connects a framework to either is not a standalone PHP runtime.

State leakage and cleanup in persistent workers

If you ever run any framework in a persistent worker, state can leak between requests. Typical sources are static properties, singletons, service containers that cache request-specific objects, open database transactions, authenticated user data held in memory, and superglobal-derived values captured early. The consequences range from stale data to one user seeing another user's data. Mitigations to verify for your setup include creating request-scoped objects per request, resetting or avoiding mutable shared services, closing connections and transactions after each request, restarting workers after a bounded number of requests, and testing with consecutive requests from different identities. Under the classic request lifetime most of this cleanup happens automatically when the process ends.

Practical use cases

• Adopting a single component inside an existing PHP application instead of a full framework.
• Building middleware-based HTTP applications, which is what the Mezzio description points to.
• Maintaining an existing laminas-mvc application, or migrating one from Zend Framework, Expressive, or Apigility, using the migration documentation.
• Learning MVC structure through the official tutorials.

Installation approach

The supplied source does not give package names, version constraints, or PHP compatibility. The usual PHP approach is Composer, and the example here assumes the Composer package name laminas/laminas-mvc, derived from the laminas-mvc name on the page. Verify it against the official documentation. The example installs the package and then reads Composer's own metadata to confirm it. It does not call any Laminas API, and it is not an application skeleton. For a real application, follow the tutorials on the official site instead of guessing a layout. Composer may ask whether to trust plugins during installation. Read any such prompt before answering.

The learning track targets PHP 8.4, with PHP 8.5 planned. Whether laminas-mvc or any other component supports PHP 8.4 is unknown from the source. If Composer cannot resolve the package for PHP 8.4, treat that as a compatibility finding rather than forcing the install.

Strengths

• Modular documentation split into components, middleware, and MVC.
• A documented migration path from older Zend-era projects.
• Tutorials aimed at both MVC and component use.

Limitations

• The MVC area is marked security-only maintenance mode on the source page.
• Overall lifecycle, release versions, license, PHP compatibility, and support dates are unknown from the supplied evidence.
• No performance claims are made here.
• The runtime example needs Composer and network access to download packages, so it is not a browser exercise.

Deployment

The source does not describe deployment. For a typical PHP application, a web server forwards requests to PHP-FPM, and only the web server is exposed. If you use FastCGI, never expose it publicly; keep it on a private interface or a local socket. For local development, bind any exposed port to 127.0.0.1. Never commit secrets such as database passwords or API keys. Provide them through the environment or a secrets mechanism. If you ever place Laminas code in a persistent-worker runtime, apply the state cleanup practices above and consult that runtime's own documentation.

Links

The official Laminas documentation at https://docs.laminas.dev/ is the only source used. Consult it for current component lists, installation instructions, tutorials, and the maintenance status of each area.

{
    "name": "learnphponline/laminas-check",
    "description": "Minimal Composer install check for a Laminas package",
    "type": "project",
    "require": {
        "php": ">=8.4"
    },
    "config": {
        "sort-packages": true
    }
}

<?php

declare(strict_types=1);

require __DIR__ . '/../vendor/autoload.php';

use Composer\InstalledVersions;

$package = 'laminas/laminas-mvc';

echo 'PHP runtime: ' . PHP_VERSION . PHP_EOL;

if (!InstalledVersions::isInstalled($package)) {
    fwrite(STDERR, $package . ' is not installed.' . PHP_EOL);
    exit(1);
}

echo $package . ' installed, version: ' . (InstalledVersions::getPrettyVersion($package) ?? 'unknown') . PHP_EOL;

composer validate
composer require laminas/laminas-mvc
php bin/check.php