Silverstripe Framework: the framework beneath the CMS

It relies only on the official repository page supplied for this guide. Where that page is silent, this guide says so.

What this project is

The repository describes Silverstripe Framework as "the MVC framework that powers Silverstripe CMS". The README calls it a "PHP framework forming the base for the Silverstripe CMS". The repository page shows a BSD-3-Clause license. Beyond that, this guide makes no claims about licensing terms, prices or support commitments.

Classification: a framework, not a CMS and not a runtime

Silverstripe Framework is a PHP application framework. It is not a standalone PHP runtime, an alternative interpreter or an application server. It runs on PHP and does not replace PHP core. PHP core is the language engine and its standard extensions. A framework is Userland PHP code that you install with the application.

The framework is also distinct from the CMS product. The README says the framework "requires a silverstripe-installer base project" and is "typically used alongside the cms module". So there are three roles:

• The framework: the MVC foundation.
• The cms module: the content-management product built on that foundation.
• The installer base project: the project skeleton the framework requires.

A comparison may help: Drupal is a CMS product built on its own stack, and a component library such as a router or HTTP package is not a CMS at all. Silverstripe Framework sits in between. It is a full framework, but the CMS user interface and editorial workflow belong to the CMS layer, not to the framework page you are studying.

Architecture

The supplied source gives only the repository layout, with no architectural documentation. The top-level names are _config, bin, client, lang, src, templates and tests. There are also composer.json, phpunit.xml.dist, phpstan.neon.dist and phpcs.xml.dist. From those names alone, we can say the project is a Composer-managed PHP codebase that has configuration, source, templates, client-side assets, language files and tests, and that it uses PHPUnit, PHPStan and PHP_CodeSniffer configuration files. The page does not document internal APIs, so this guide does not describe classes, ORM methods or template syntax. Use the official documentation linked from the README for those.

Execution and content model

The source states that this is an MVC framework. It does not document its request lifecycle, worker support or any persistent-process mode. Treat those points as unknown.

The conventional PHP model is a classic request lifetime. A web server starts PHP for each request, the application boots, handles the request, sends a response and discards its in-process state. Persistent workers work differently. A long-running process boots once and serves many requests. That can cut repeated boot cost, but it creates state leakage risks:

• Static properties, singletons and service containers can keep data from one request and expose it to the next.
• User identity, locale, cached query results and open transactions can leak between visitors.
• Open file handles, database connections and temporary files can accumulate.

Cleanup for a persistent worker means resetting or recreating request-scoped services after every request, clearing static caches, closing or validating connections and restarting workers on a policy. Swoole and Open Swoole are different projects, so never assume that documentation, extensions or behavior for one applies to the other. Nothing in the supplied source says Silverstripe Framework is designed or supported for persistent workers. Until official documentation says otherwise, assume classic request-lifetime hosting.

Content modelling, such as page types or data objects, is part of the framework-and-CMS ecosystem. This source does not describe it, so the guide does not go further.

Practical use cases

The evidence supports one conservative use case: building a PHP web application on the framework that underpins Silverstripe CMS. Use it when you want an MVC foundation that matches that CMS ecosystem. If you only need editorial tooling, the CMS product is the relevant starting point, and the framework comes with it as its base. If you need a minimal micro-service or a long-running worker, the supplied source gives no basis for choosing this framework.

Installation approach

The README says to follow the official getting-started instructions and says the framework requires a silverstripe-installer base project. It does not give Composer package names or commands in the supplied text, so this guide does not invent them. In practice, you create a base project by following the official getting-started path, and then add or confirm the cms module if you want the CMS product. Do not clone the framework repository and try to run it alone as an application.

The example below performs a small, safe check that fits this model. It reads a composer.json file and lists any requirements whose names contain the text silverstripe. It does not boot Silverstripe and uses no Silverstripe APIs. The script is plain PHP and I have written it for PHP 8.4. That choice concerns only the helper script. The supplied source does not state which PHP versions Silverstripe Framework supports, so that remains unknown.

Strengths

• A clear role: the README states what the framework is for and how it relates to the CMS.
• A visible open-source repository with a BSD-3-Clause license shown, an issue tracker, contribution guidance and a security area.
• Quality tooling configuration in the repository, namely PHPUnit, PHPStan and PHP_CodeSniffer files.

Limitations and unknowns

• Current version, release cadence, PHP compatibility, deprecations and support status are not established by the supplied page, so lifecycle is marked unknown.
• No performance claims can be made from the evidence.
• The framework is not usable alone, because it requires an installer base project.
• Persistent-worker behavior and safe cleanup practices are undocumented in the source.
• Hosting requirements are referenced by the README under a server requirements link, but that page was not supplied, so check it before choosing hosting.

Deployment

The supplied source gives no deployment procedure. Plan on the standard model: a web server and PHP processing one request at a time, with the application produced from an installer-based project. Never expose FastCGI publicly. Bind any local development port to 127.0.0.1. Before production, read the official server requirements and changelogs referenced from the repository. The exercise here needs a local PHP command-line install and is not a browser exercise.

Links

Use the official repository as the single entry point. It leads to the getting-started instructions, server requirements, changelogs, bug trackers and contribution guide mentioned in the README.

<?php

declare(strict_types=1);

$path = $argv[1] ?? __DIR__ . '/../sample/composer.json';

if (!is_file($path)) {
    fwrite(STDERR, "File not found: {$path}\n");
    exit(1);
}

$json = file_get_contents($path);
if ($json === false) {
    fwrite(STDERR, "Could not read: {$path}\n");
    exit(1);
}

try {
    $data = json_decode($json, true, 512, JSON_THROW_ON_ERROR);
} catch (JsonException $e) {
    fwrite(STDERR, 'Invalid JSON: ' . $e->getMessage() . "\n");
    exit(1);
}

$found = [];
foreach (['require', 'require-dev'] as $section) {
    $entries = $data[$section] ?? [];
    if (!is_array($entries)) {
        continue;
    }
    foreach ($entries as $name => $constraint) {
        if (str_contains(strtolower((string) $name), 'silverstripe')) {
            $found[] = "{$section}: {$name} {$constraint}";
        }
    }
}

echo "Checked: {$path}\n";

if ($found === []) {
    echo "Silverstripe-related requirements: none found\n";
    exit(0);
}

echo "Silverstripe-related requirements:\n";
foreach ($found as $line) {
    echo " - {$line}\n";
}

{
    "name": "example/learning-fixture",
    "description": "Fixture with no Silverstripe packages, used only to exercise the checker.",
    "require": {
        "php": "^8.4"
    }
}

php --version
php bin/check-composer.php
php bin/check-composer.php path/to/your/composer.json