Study guide · Frontend, TypoScript and Design

From content to a designed website: TypoScript, site packages and design

As of November 15, 2026 · TYPO3 14.3 LTS · about 26 min read

The frontend is what clients see and judge. As a consultant you need to explain how TYPO3 turns maintained content into a designed website. On this page you follow a client project from the site package through TypoScript to the design system. Afterwards you can estimate effort, classify errors and weigh a ready-made theme against a custom design.

The example: the Seetal holiday region

An agency looks after the Seetal holiday region. The main website gets its own design, created by a designer. On top of that comes a small website for the guest card, which should go online quickly and cheaply. Later the towns of the region also want their own websites with a similar structure. The editorial team also wants a backend in which they can make few mistakes.

How TYPO3 renders a page

The editorial team maintains pages, content elements and records. This content lives in the database. When a visitor requests a page, TYPO3 builds HTML from it. Two tools work together for this.

TypoScript is the configuration language for the frontend. It defines which template is rendered, how menus are built and how content elements are output. TypoScript is not a programming language in the strict sense, and it does not run in the browser. It does not create database tables, that is done through the table configuration TCA and the file ext_tables.sql. Users are created in the backend.

Fluid is the template engine of TYPO3. A Fluid template consists of HTML and Fluid tags, the ViewHelpers. They insert content, create links and images or check conditions. Fluid splits the output into layouts for the frame, templates for the page and partials for reusable pieces.

Content in the database pages, content elements, records Site Package TypoScript configures, provides data (menus, columns) PAGEVIEW Fluid writes the HTML layouts, templates, partials escapes output Finished HTML in the browser styled with CSS and JavaScript
TypoScript configures and provides data, Fluid writes the HTML.

In the past, people wrote whole pages with HTML directly in TypoScript. Today the split is clear: TypoScript configures and provides data, Fluid takes care of the HTML. The object PAGEVIEW renders the page with a Fluid template. Menus come from a data processor such as the MenuProcessor. This way the markup stays with the frontend developers, and TypoScript still remains the foundation of the frontend configuration.

For the backend there is TSconfig. It has the same syntax as TypoScript, but different properties. You use it to adapt the backend for editors. More on that further down.

Where do you find all properties? In the TypoScript Reference, also called “TypoScript Explained”, on docs.typo3.org. Pick the matching version there, for example 14.3. Properties change or disappear between versions.

The site package

A site package is an extension that bundles everything for the look and the basic configuration of a website. It typically contains:

  • A composer.json file and the definition of a site set with TypoScript, settings and page TSconfig.
  • Fluid templates, layouts and partials.
  • Public assets such as CSS, JavaScript, fonts and images.
  • Often also backend layouts, language files and custom content elements.

The content of the pages does not belong in it. It stays in the database. Database credentials do not belong in the package either, but in the environment configuration of the server.

In Composer installations the site package usually lives as a local package in the folder packages. Composer then installs it like any other extension. The folder fileadmin, on the other hand, is for editors' files, not for templates.

Why a site package instead of templates in the database? Because files live in the repository. There you can version them with Git, check them in code review and deploy them automatically. The same templates run identically on development, staging and live. Configuration in the database, by contrast, is hard to trace. A design relaunch only changes the package, the content stays untouched. That makes projects maintainable and scalable.

A starting point comes from the Sitepackage Builder on get.typo3.org. It creates a working skeleton with folder structure, composer.json, site set and example templates. It does not design anything for you, you build the actual design on top of it. The Site Package Tutorial in the documentation explains the steps.

Security through Fluid: Fluid automatically escapes variables as HTML when it outputs them. Injected code then shows up as harmless text, which protects against cross-site scripting. If you deliberately output unescaped HTML, for example with the ViewHelper f:format.raw, you must be sure that the content is trustworthy or sanitized.

Site configuration, site sets and settings

Every website in TYPO3 has a site configuration. You find it in the module “Sites”, submodule “Setup”. It defines the domain, the languages, error handling, routing and the included site sets. Colors and fonts are not in there, they come from the site package.

Site sets have existed since TYPO3 13. A set is a package of TypoScript, settings and page TSconfig. A site includes it in its configuration. Extensions and site packages ship their own sets, for example “SEO Sitemap” or the set of a theme. Since TYPO3 14 a set can also bring route enhancers.

Site settings are settings with a type and a default value, such as a color, a logo or a page ID. A set defines them, and each site can override them. Authorized users change them in the module “Sites”, submodule “Settings”, without touching code. They are available in TypoScript, TSconfig and Fluid. In TypoScript you use them like constants.

Reading TypoScript: objects, properties, functions

TypoScript is line based. A line consists of a path, an operator and a value. Dots separate the levels of the path. The equals sign assigns a value, and TYPO3 removes spaces at the start and end of the value.

page = PAGE
page.10 = TEXT
page.10.value = Hello Seetal
page.10.wrap = <p>|</p>

# Same effect, written shorter
page.10 {
  value = Hello Seetal
  wrap = <p>|</p>
}
TypoScript example. page becomes an object of type PAGE. page dot 10 becomes a TEXT object with the value Hello Seetal, wrapped in a paragraph tag. Below, the same is written again with curly braces, so you do not have to repeat page dot 10 on every line.

You should keep three terms apart:

  • An object is defined by its type, such as PAGE, TEXT, CONTENT or PAGEVIEW.
  • A property configures an object, such as value, wrap or typeNum.
  • A function such as stdWrap, typolink or imgResource offers reusable processing. It wraps, replaces or fetches data and is available on many properties.

Curly braces nest paths, so you do not repeat the shared part on every line. The closing brace sits at the start of its own line. Anything that follows an opening or closing curly brace on the same line counts as a comment, even without a comment sign.

Multi-line values go between round brackets. Constants inside them are still replaced. If the closing round bracket is missing, everything up to the end of the file becomes part of the value. That includes comments, conditions and imports. The configuration that follows then simply stops working, and the error is hard to find.

A dot inside a name: Sometimes a name itself contains a dot, for example in FlexForm details. Then you escape it with a backslash in front. That way it stays a single name and does not become a deeper level.

page.20 = TEXT
page.20.value (
  Welcome to the holiday region.
  Nice to have you here.
)

myIdentifier.my\.identifier = someValue
Code example. A multi-line value between round brackets. Below it, a path in which the dot in my dot identifier is escaped with a backslash.

Comments start with a hash sign or two slashes and run to the end of the line. Multi-line comments go between slash star and star slash. Important: after an assignment with an equals sign, these characters belong to the value.

Copy, reference, delete, modify

Besides assignment, TypoScript knows four more operators.

Copying with the less-than sign copies a path with its value and all sub paths to another place. The copy is made at exactly the moment the parser reads the line. Later changes to the original do not affect the copy. This follows the principle “Don't repeat yourself”: define once, use many times.

Referencing with an equals sign followed by a less-than sign points to the original instead of copying it. If you change the original later, the target changes too. But be careful: the reference is not a general tool of the language. TYPO3 only resolves it when rendering the frontend, and only for content objects: wherever an object such as TEXT or COA is rendered, plus in parseFunc. It does not work for plain values such as wrap, in constants or in TSconfig, there you use the copy. The official TypoScript Reference only names the path tt_content and recommends it there for performance reasons.

lib.a = TEXT
lib.a.value = One
lib.b < lib.a
lib.a.value = Two
# lib.b.value is still "One"

tt_content.text =< lib.contentElement
Code example. lib.a becomes a TEXT with the value One. lib.b is a copy of lib.a. Afterwards lib.a gets the value Two. lib.b keeps the value One. In the last line tt_content dot text references the object lib.contentElement.
Copy lib.b < lib.a Reference =< lib.a first One, then Two when parsed lib.b stays at One its own duplicate, independent of the original lib.contentElement the original points to tt_content.text follows every change no duplicate, just a pointer References only work in the frontend on content objects not on plain values, constants or TSconfig
A copy keeps the old state, a reference follows the original, but only for content objects in the frontend.

Deleting with the greater-than sign removes a path together with all its sub paths.

Modifying with a colon followed by an equals sign changes an existing value through a predefined function. That way you do not have to rewrite values from extensions completely. The functions are called prependString, appendString, removeString, replaceString, addToList, removeFromList, uniqueList, reverseList, sortList and getEnv.

page.10 >

foo = ab
foo := appendString(cd)
# foo is now "abcd"

numbers = 3,1,2
numbers := sortList()
# numbers is now "1,2,3"

letters = a,b,a
letters := uniqueList()
# letters is now "a,b"
Code example. page dot 10 is deleted. foo has the value ab, appendString adds cd, and the result is abcd. The list 3, 1, 2 is sorted ascending with sortList into 1, 2, 3. The list a, b, a becomes a, b with uniqueList.

Without parameters, sortList sorts in ascending order. uniqueList removes duplicate entries, and reverseList reverses the order.

Conditions and imports

Conditions go in square brackets and use the Symfony Expression Language. One example is the check whether a frontend user is logged in. ELSE in square brackets gives you an alternative branch. END and GLOBAL in square brackets end a condition, and both work the same way. A condition also ends automatically at the end of a file or a record.

Several criteria belong in one pair of brackets. You combine them with and, or two ampersands, and with or, or two vertical bars. With not, or an exclamation mark, you negate a criterion.

# Correct
[frontend.user.isLoggedIn && tree.level > 1]
  page.20 = TEXT
  page.20.value = Welcome back
[END]

# Wrong: the second criterion is silently ignored
[frontend.user.isLoggedIn] && [tree.level > 1]
Code example. Correct: a single pair of brackets holds both criteria, a logged-in frontend user and a page level greater than 1, combined with two ampersands. Then comes END. Below it the wrong old notation with two separate pairs of brackets.

More rules for conditions:

  • Conditions must not be placed inside curly braces. They always apply at the top level.
  • A new condition ends the previous one. So you cannot nest them in the same file, only across separate files.
  • The frontend and the backend have different variables. Conditions on logged-in frontend users are meant for frontend TypoScript. In the backend no frontend user is logged in, so such a condition never matches in TSconfig.
  • You may use constants and site settings in conditions, for example to maintain a page ID centrally instead of hard-coding it.
  • The operator with two question marks, which gives constants a fallback value, does not work in conditions. There you use or.
[traverse(page, "uid") == {$myPageUid}]
  page.10.value = This is the offers page
[END]
Code example. The condition uses traverse to check whether the uid of the current page equals the constant myPageUid.

Imports include further files. You write the keyword @import followed by a path in quotes. Fixed rules apply:

  • Paths start with EXT and a colon, or relatively with a dot and a slash. A path with two dots going back to the parent directory is not allowed.
  • A wildcard is only allowed at file level, not at directory level. TYPO3 loads several files in alphabetical order.
  • Directories are not searched recursively.
  • Since TYPO3 12 an import may sit inside a condition. That gives you conditional imports, and this is also the way to nest conditions.
  • An import is not allowed inside curly braces.
@import 'EXT:seetal_sitepackage/Configuration/TypoScript/setup.typoscript'

[frontend.user.isLoggedIn]
  @import './Navigation/*.typoscript'
[END]
Code example. One import loads the file setup.typoscript from the site package. A second import loads all typoscript files in the folder Navigation, but only when a frontend user is logged in.

Checking and securing TypoScript

Where does a setting come from, and why does it not take effect? For this there is the module “Sites”, submodule “TypoScript”. It has several views:

  • “Active TypoScript” shows the resolved tree as it applies to the selected page. Here you can simulate conditions.
  • “Included TypoScript” shows which files, sets and records are included, and in which order.

With these you quickly find out whether a setting is overridden, or whether a forgotten round bracket swallows the rest of the file. You check page TSconfig in the matching module in the same way.

All these modules are restricted to administrators. The reason is security. TypoScript can address USER objects that run PHP code. Anyone allowed to change TypoScript could gain admin rights this way. That is why there is no permission level below admin for it. In a project, TypoScript is best kept versioned in the site package.

Today TypoScript is usually included through the site set of the site package. Older projects still use TypoScript records on the root page.

TSconfig: the backend for editors

TSconfig uses the syntax of TypoScript, but works in the backend. There are two kinds:

  • Page TSconfig applies to an area of the page tree. You use it to set default values for new records, hide fields, restrict selection lists and the offered content elements, and configure the rich text editor.
  • User TSconfig applies to users and user groups, for example for options and views.

This way editors only see what they need. Forms become leaner, and fewer mistakes happen.

TCAdefaults.tt_content.header_layout = 2
Page TSconfig example. For new content elements, heading level 2 is preset.

By the way, you do not define required fields in TSconfig, but in the table configuration TCA. That also lives neatly in the site package.

Ready-made themes: Camino and the Bootstrap Package

Not every project needs a completely custom design. Two ready-made themes are especially important.

Camino is the default theme that has shipped with the Core since version 14. It is a system extension, and the Composer package is called typo3/theme-camino. The name is Spanish and means “the way”. The goal is a working website within minutes, without any external libraries. Camino brings backend layouts, its own content elements, four selectable color schemes, a replaceable logo and menus. It suits a quick start or demos. For an individual design you use your own site package.

The Bootstrap Package is a widely used third-party extension, not a system extension of the Core. It is based on the CSS framework Bootstrap and delivers a complete, responsive frontend. On top come many content elements such as carousel, accordion, tabs or timeline, plus several backend layouts. Its TypoScript comes through site sets.

Why a standardized framework? It saves development time and offers a proven, maintainable foundation. Components and responsive behavior are tested, and the package is actively maintained. The price: without customization the website often looks similar to others. When the package is updated, you have to check your own customizations.

Adapting it to the brand works through settings and variables, for example for colors. All SCSS variables can be set through settings. You override templates through your own paths in the site package.

When is the Bootstrap Package a poor fit? When a highly individual design with its own frontend framework is required. Or when the frontend team deliberately uses a different CSS framework. Then bending the package often costs more than your own site package. Responsive behavior and many standard content elements, on the other hand, are exactly what speaks for it.

Accessibility: A framework creates a good foundation, but it does not replace testing the actual project. No website becomes accessible automatically through a theme. If you change colors, you still have to meet the contrast requirements. After customizing, you test contrast, keyboard operation and screen readers again.

Custom corporate design and long-term customization? No Yes Ready-made theme Camino or Bootstrap Package quick start, many content elements Custom site package costs more at first, fits the design exactly, stays in your hands Also possible: build on a theme and customize it in your own package.
Ready-made theme or custom site package? It depends on the design and on how long the site will live.

Design systems and component libraries

A design system is a collection of rules, components and templates that ensures a consistent look. Even when many people work on the website, all pages then look the same. A well-known example is Material Design by Google. Typical parts are:

  • Design tokens, that is basic values such as colors, font sizes and spacing.
  • Documented components with variants and rules for when to use them.
  • Guidelines for accessibility and tone of voice.

A component library provides reusable elements such as buttons, teasers or forms in a consistent way. Tools such as Figma or Storybook help with maintenance and coordination. The benefits:

  • The look is consistent across all pages.
  • New pages are built faster from existing building blocks.
  • A change to a component takes effect everywhere it is used. That is why you also have to check it everywhere.

So testing is still needed, and unlimited design freedom would be the opposite of a design system.

In TYPO3, components usually correspond to content elements and Fluid partials in the site package. Each component is implemented exactly once if possible and used everywhere. Editors choose from defined variants instead of designing freely.

Accessibility is solved once in the components: contrast, visible focus states and semantic structure. Every page inherits this quality. That is far more efficient than fixing every page on its own. Editors remain responsible for content such as alternative texts and meaningful headings.

Collaboration: Design and development must work in close coordination. Otherwise new design variants are missing in the code, or the code has variants the design does not know. Shared rules, names and processes keep both in sync.

Key points

  • TypoScript is the configuration language of the frontend. TSconfig uses the same syntax for the backend.
  • Today TypoScript configures and provides data, while Fluid writes the HTML and escapes output against cross-site scripting.
  • A site package bundles templates, assets and configuration, versioned and usually in the folder packages. Content stays in the database.
  • Site sets bring TypoScript, settings and page TSconfig. Settings vary colors or logos per site.
  • Copying creates an independent copy at parse time. The reference only works when the frontend renders content objects, not in constants or TSconfig.
  • After an assignment, comment signs are part of the value.
  • All criteria of a condition belong in one pair of brackets. Conditions never sit inside curly braces.
  • Since TYPO3 14 only imports remain, the old INCLUDE_TYPOSCRIPT syntax has been removed.
  • The TypoScript modules under “Sites” are for administrators only, because TypoScript can call PHP.
  • Camino is the Core theme since TYPO3 14, the Bootstrap Package is a third-party theme. You never change third-party extensions directly.
  • A design system with a component library keeps the look consistent and solves accessibility centrally.

Terms

Site package
Extension with templates, assets and configuration for the look of a website.
Site set
Package of TypoScript, settings and page TSconfig that a site includes in its configuration.
Site settings
Settings of a site with type and default value, editable in the module Sites under Settings.
Fluid
Template engine of TYPO3 with layouts, templates, partials and ViewHelpers.
TypoScript
Configuration language that controls the behavior and output of the frontend.
TSconfig
Backend configuration with TypoScript syntax, as page TSconfig and user TSconfig.
stdWrap
Versatile TypoScript function that wraps, replaces or fetches values.
Camino
Default theme in the Core since TYPO3 14.
Bootstrap Package
Third-party theme based on the CSS framework Bootstrap.
Design token
Basic value of a design system, such as a color, a font size or a spacing.
Component library
Collection of consistently implemented, reusable design elements.

As of: November 15, 2026 (TYPO3 14.3 LTS)

Sources:

  • TypoScript Reference 14.3, chapters syntax, operators, comments, conditions and imports
  • TYPO3 Explained 14.3 and Getting Started 14.3, chapters TypoScript, TSconfig, site handling and site settings
  • Site Package Tutorial 14.3 and the Sitepackage Builder on get.typo3.org
  • Documentation of EXT:bootstrap_package and of the system extension theme_camino
  • TYPO3 14 changelog (Camino, route enhancers in site sets, removal of INCLUDE_TYPOSCRIPT)
  • Source code TYPO3 14.3 (typo3/cms-core, typo3/cms-tstemplate), checked for comments after braces and the access rights of the TypoScript modules
  • Learning objectives TYPO3 CMS Certified Consultant 14 LTS, area Frontend, TypoScript and Design

This study guide was written with AI and checked against the sources.

Certifications & exams

Which exam comes next?

You can already practise for 51 exams, and 16 are up for a vote. See all certifications with their official information, cast your vote or suggest your exam.

See all certifications