TypoScript

TypoScript is the purely declarative configuration language at the heart of TYPO3, one of the longest-lived open-source enterprise content management systems. It is not a general-purpose programming language and, strictly speaking, not really a “scripting” language despite its name — it is a means of configuring a TYPO3 website. With TypoScript you describe, as a hierarchical tree of objects and properties, how a site’s frontend should be rendered and how its backend should behave. That configuration is parsed into a large, system-wide PHP array that TYPO3 consults as it builds each page.

History & Origins

TypoScript exists because of TYPO3. The CMS was created by the Danish developer Kasper Skårhøj, who began work on it in 1997 and released it publicly as version 3.0 in 2001. During those pre-release years, TYPO3 needed a compact, powerful way to express how pages should be constructed — something more flexible than fixed templates but more approachable, in theory, than writing raw PHP for every site. TypoScript emerged from that need, taking shape around the turn of the millennium (the precise date it was first introduced is not well documented) and arriving fully formed as a distinctive part of TYPO3 by its first public release.

From the beginning, TypoScript reflected TYPO3’s philosophy of separating content, configuration, and presentation. Editors managed content in the database through the backend; integrators used TypoScript to describe how that content should be selected, transformed, and rendered. This division let a single TYPO3 installation power large, complex, multi-site and multilingual deployments — a strength that made TYPO3 especially popular for enterprise and public-sector websites in German-speaking Europe.

Design Philosophy

TypoScript is built around a small number of consistent ideas:

1. Everything is a tree of objects and properties. Configuration is expressed as an object hierarchy. page = PAGE declares an object; page.10 = TEXT gives it a child; nested blocks group related properties together.
2. Declarative, not procedural. You state what the configuration should be, not how to compute it step by step. There is no traditional control flow — no loops or functions in the programming sense — only assignments, references, and conditions that switch whole blocks of configuration on or off.
3. One global configuration array. All of a site’s TypoScript is parsed and merged into a single, deeply nested PHP array. Later definitions can extend, override, copy, or remove earlier ones.
4. Inheritance and reuse. Values can be copied from elsewhere in the tree, cleared, or overridden, so integrators can build a base configuration and specialize it per page, per site, or per condition.

Key Features

• Object assignment (=). The core operation. page.10.value = Hello world sets a property to a value.
• Block nesting ({ }). Curly braces group many property assignments under one object, improving readability. The closing } must be the first non-space character on its line.
• Copying (<) and clearing (>). lib.menu < temp.menu copies a whole sub-tree; page.10 > removes an object and its properties.
• Conditions ([ ... ]). Conditions such as [date("j") == 9] or checks on the request, site, or user break parsing to include or skip the configuration that follows, ending at [GLOBAL] or [END]. Modern TYPO3 evaluates these with the Symfony Expression Language.
• Constants and setup. TypoScript templates are typically split into constants (simple named values, often surfaced in a Constant Editor for non-developers) and setup (the full object configuration that references those constants via {$...}).
• Two dialects. Frontend TypoScript steers rendering; TSconfig (Page TSconfig and User TSconfig) configures the backend editing experience.

A small but complete example shows the object-and-property structure:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# Define the page object that renders the frontend
page = PAGE
page {
    typeNum = 0

    # A content object numbered 10, of type TEXT
    10 = TEXT
    10 {
        value = Hello world
        wrap = <h1>|</h1>
    }
}

# A condition: only applies on the 9th day of the month
[date("j") == 9]
    page.10.value = It is the 9th day of the month!
[END]

Evolution

TypoScript’s role has shifted significantly over TYPO3’s lifetime. In early versions, TypoScript did much of the templating work directly, combined with marker-and-subpart HTML skeletons in which placeholders were substituted with rendered content. That approach was powerful but could become dense and hard to maintain.

The turning point came with the Extbase framework and the Fluid templating engine, introduced with TYPO3 4.3 (2009) and adopted as the standard templating approach through the 6.x series (around 2012). Fluid brought a clean, HTML-based templating syntax with its own control structures, and TypoScript increasingly stepped back from generating markup. In modern TYPO3, TypoScript’s job is often described as gathering and pre-processing data — selecting content, setting plugin and global options, and acting as a bridge between database records and the Fluid templates that actually produce HTML.

Over the same period, TypoScript’s own syntax and tooling matured: conditions moved to the Symfony Expression Language, site handling took over much configuration that once lived only in TypoScript, and the parser and diagnostics were modernized. The language nevertheless remains a defining, unavoidable part of building and maintaining a TYPO3 site.

Current Status

TypoScript is actively used because TYPO3 is actively developed. TYPO3 follows a long-term-support release cadence: 13.4 LTS arrived on 15 October 2024, and 14 LTS followed on 21 April 2026, each bundling TypoScript for frontend configuration and TSconfig for the backend. TypoScript is not distributed or run on its own — it only has meaning inside a TYPO3 installation, which is a PHP application typically run on a standard LAMP-style stack. For that reason it has no standalone interpreter, package, or Docker image of its own; you exercise it by installing and configuring TYPO3.

TypoScript is widely regarded as having a steep learning curve — its terse syntax, global merged configuration, and object-reference model can be confusing to newcomers — but it remains central to professional TYPO3 work, and the ecosystem includes extensive official documentation, tutorials, and integrator training built around it.

Why It Matters

TypoScript is a rare example of a domain-specific configuration language that has endured for roughly a quarter-century as the backbone of a major open-source CMS. It embodies a clear architectural stance — separate content from configuration from presentation — and gives integrators a single, declarative surface for controlling an entire website’s behaviour without editing core code. Its long evolution, from doing hands-on HTML templating to orchestrating data for Fluid templates, mirrors the broader shift in web development toward cleaner separation between logic, configuration, and view. For the large community that builds enterprise, government, and institutional sites on TYPO3 — particularly across German-speaking Europe — TypoScript is not a historical curiosity but a daily, working tool.