TYPO3: an enterprise PHP content management system

It relies only on the official TYPO3 documentation landing page, so many details are marked unknown rather than guessed.

What TYPO3 is

The official documentation describes TYPO3 CMS as an Open Source Enterprise Content Management System powered by PHP. It is a CMS product: an application that editors log into and that renders websites. It is not a PHP runtime, not an alternative interpreter, not an async library and not a framework adapter. PHP core is the language engine that executes the code. TYPO3 is an application running on top of it.

TYPO3 is also a different product from Drupal CMS or any other CMS. Do not mix their documentation, configuration formats or extension systems. Likewise, a CMS product is not the same as a framework component. A CMS ships an editor backend and a content model, while a framework component is a library you wire into your own application.

Architecture and content model

The landing page shows the main building blocks and where each is documented:

• Backend for editors. The Editors guide covers logging into the TYPO3 backend, working with the page tree, creating and managing content, and handling translations.
• Site packages. A site package, or theme, holds the presentation of a site. A tutorial builds one from scratch.
• Fluid. A PHP template engine, described as the de facto standard for HTML-based output in TYPO3. ViewHelpers add logic to templates.
• TypoScript and TSconfig. Frontend TypoScript improves the frontend output of a site. TSconfig options customize the backend.
• TCA (Table Configuration Array). It maps raw database tables to records in the TYPO3 backend and in Extbase.
• Extensions. TYPO3 Explained introduces creating an extension. Community extensions are documented separately and listed in the TYPO3 Extension Repository (TER).

In short, content lives in database tables, TCA describes how those tables appear as editable records, and Fluid with TypoScript turns that content into output. This is a mental model drawn from the page. Verify the details in the linked reference chapters.

Execution model

The landing page does not describe the request lifecycle. It does not say whether TYPO3 supports persistent workers, long-running servers or anything other than a conventional PHP setup. Treat that as unknown. In a classic request lifetime, PHP state is built and discarded for each request. In a persistent worker, objects, static properties, singletons, caches and open connections can survive between requests. Data from one visitor or editor can then leak into the next response unless the application resets it. If you ever consider such a mode, first confirm in the official documentation that it is supported, and identify which state must be cleaned up after every request. Do not assume it is safe. Swoole and Open Swoole are separate projects and are not part of TYPO3.

Practical use cases

Based on the source, TYPO3 fits sites where editors need a backend with a page tree, managed content and translations. It also fits teams that want to extend the platform with their own extensions and site packages. The "enterprise" label comes from the documentation. This guide does not make performance, scalability or security claims.

Installation approach

The documentation points to the official Getting started guide for installation. It says the download site lists the different TYPO3 versions and their system requirements, and that sources can be downloaded there. The documentation suggests installing TYPO3 using Composer. Exact package names, commands, supported PHP versions and current release status are not on the supplied page, so they are unknown here. This guide therefore does not invent install commands. Follow the Getting started guide and compare its requirements with your environment.

The learning track uses PHP 8.4, with PHP 8.5 planned. Whether a given TYPO3 version supports PHP 8.4 is unknown from the supplied evidence. Check the official requirements before choosing a version.

The example in this guide

The single example is a preparatory requirements checker, not a TYPO3 installation. You copy the minimum PHP version and required PHP extensions from the official requirements into a JSON file, and the script compares them with your local PHP. The JSON file ships with null and empty values, so the script reports unknown until you fill it in. It needs only a PHP 8.4 CLI, with no Composer and no network. It is not a browser exercise.

Strengths

• Official documentation is organized by audience: getting started, site package tutorial, editors guide and references.
• The reference set covers API and security guidelines, the core changelog with deprecation migration help, Fluid, TypoScript and TCA.
• A documented extension path, with a repository for community extensions.
• Composer is the suggested installation method.

Limitations and unknowns

• Current version, support status, PHP compatibility, license and pricing are unknown from the supplied source.
• Deployment topologies, web server configuration and hosting requirements are not described on the landing page.
• TYPO3 brings its own concepts, such as TCA, TypoScript and Fluid, which take time to learn.
• Extension quality and compatibility vary, so check the documentation of each extension.

Deployment notes

The source gives no deployment procedure. As general safety guidance, keep any local development server bound to 127.0.0.1 and never expose FastCGI publicly. Use the official documentation for production hosting, upgrades and security, and read the core changelog before upgrading so you can migrate away from deprecated functionality.

Where to go next

Start with the Getting started guide, then the site package tutorial. Read TYPO3 Explained when you are ready to write an extension. Use the Fluid, TypoScript and TCA references while building. All of these are reachable from the official documentation page listed below.

{
  "minimumPhp": null,
  "requiredExtensions": [],
  "note": "Fill these values from the official TYPO3 system requirements for the version you choose. null and empty mean unknown."
}

<?php

declare(strict_types=1);

$file = __DIR__ . '/requirements.json';
$raw = file_get_contents($file);
if ($raw === false) {
    fwrite(STDERR, "Cannot read requirements.json\n");
    exit(1);
}

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

echo 'Local PHP version: ' . PHP_VERSION . "\n";

$minimum = $data['minimumPhp'] ?? null;
$extensions = $data['requiredExtensions'] ?? [];

if (!is_string($minimum) || $minimum === '') {
    echo "Minimum PHP version: unknown (fill in requirements.json from the official requirements)\n";
    exit(2);
}

$ok = true;

if (version_compare(PHP_VERSION, $minimum, '>=')) {
    echo "PHP version OK (>= {$minimum})\n";
} else {
    echo "PHP version too old (needs >= {$minimum})\n";
    $ok = false;
}

if (!is_array($extensions) || $extensions === []) {
    echo "Required extensions: unknown (list is empty)\n";
}

foreach (is_array($extensions) ? $extensions : [] as $name) {
    $loaded = extension_loaded((string) $name);
    echo ($loaded ? 'OK      ' : 'MISSING ') . $name . "\n";
    if (!$loaded) {
        $ok = false;
    }
}

exit($ok ? 0 : 1);

cd typo3-check
php check.php